activemerchant 1.49.0 → 1.50.0

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

@@ -0,0 +1,226 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class S5Gateway < Gateway
+      self.test_url = 'https://test.ctpe.io/payment/ctpe'
+      self.live_url = 'https://ctpe.io/payment/ctpe'
+
+      self.supported_countries = ['DK']
+      self.default_currency = 'EUR'
+      self.supported_cardtypes = [:visa, :master, :maestro]
+
+      self.homepage_url = 'http://www.s5.dk/'
+      self.display_name = 'S5'
+
+      SUPPORTED_TRANSACTIONS = {
+        'sale'      => 'CC.DB',
+        'authonly'  => 'CC.PA',
+        'capture'   => 'CC.CP',
+        'refund'    => 'CC.RF',
+        'void'      => 'CC.RV',
+      }
+
+      def initialize(options={})
+        requires!(options, :sender, :channel, :login, :password)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        request = build_xml_request do |xml|
+          add_payment(xml, money, 'sale', options)
+          add_account(xml, payment)
+          add_customer(xml, payment, options)
+          add_recurrence_mode(xml, options)
+        end
+
+        commit(request)
+      end
+
+      def refund(money, authorization, options={})
+        request = build_xml_request do |xml|
+          add_identification(xml, authorization)
+          add_payment(xml, money, 'refund', options)
+        end
+
+        commit(request)
+      end
+
+      def authorize(money, payment, options={})
+        request = build_xml_request do |xml|
+          add_payment(xml, money, 'authonly', options)
+          add_account(xml, payment)
+          add_customer(xml, payment, options)
+          add_recurrence_mode(xml, options)
+        end
+
+        commit(request)
+      end
+
+      def capture(money, authorization, options={})
+        request = build_xml_request do |xml|
+          add_identification(xml, authorization)
+          add_payment(xml, money, 'capture', options)
+        end
+
+        commit(request)
+      end
+
+      def void(authorization, options={})
+        request = build_xml_request do |xml|
+          add_identification(xml, authorization)
+          add_payment(xml, nil, 'void', options)
+        end
+
+        commit(request)
+      end
+
+      def verify(credit_card, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((pwd=).+(/>))i, '\1[FILTERED]\2').
+          gsub(%r((<Number>).+(</Number>))i, '\1[FILTERED]\2').
+          gsub(%r((<Verification>).+(</Verification>))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_identification(xml, authorization)
+        xml.Identification do
+          xml.ReferenceID authorization
+        end
+      end
+
+      def add_payment(xml, money, action, options)
+        xml.Payment(code: SUPPORTED_TRANSACTIONS[action]) do
+          xml.Memo         "return_code=#{options[:memo]}" if options[:memo]
+          xml.Presentation do
+            xml.Amount     amount(money)
+            xml.Currency   options[:currency] || currency(money)
+            xml.Usage      options[:description]
+          end
+        end
+      end
+
+      def add_account(xml, creditcard)
+        xml.Account do
+          xml.Number        creditcard.number
+          xml.Holder        "#{creditcard.first_name} #{creditcard.last_name}"
+          xml.Brand         creditcard.brand
+          xml.Expiry(year: creditcard.year, month: creditcard.month)
+          xml.Verification  creditcard.verification_value
+        end
+      end
+
+      def add_customer(xml, creditcard, options)
+        address = options[:billing_address]
+        xml.Customer do
+          xml.Contact do
+            xml.Email      options[:email]
+            xml.Ip         options[:ip]
+            xml.Phone      address[:phone] if address
+          end
+          add_address(xml, address)
+          xml.Name do
+            xml.Given      creditcard.first_name
+            xml.Family     creditcard.last_name
+            xml.Company    options[:company]
+          end
+        end
+      end
+
+      def add_address(xml, address)
+        return unless address
+
+        xml.Address do
+          xml.Street     "#{address[:address1]} #{address[:address2]}"
+          xml.Zip        address[:zip]
+          xml.City       address[:city]
+          xml.State      address[:state]
+          xml.Country    address[:country]
+        end
+      end
+
+      def add_recurrence_mode(xml, options)
+        if options[:recurring] == true
+          xml.Recurrence(mode: "REPEATED")
+        else
+          xml.Recurrence(mode: "INITIAL")
+        end
+      end
+
+      def parse(body)
+        results  = {}
+        xml = Nokogiri::XML(body)
+        resp = xml.xpath("//Response/Transaction/Identification")
+        resp.children.each do |element|
+          results[element.name.downcase.to_sym] = element.text
+        end
+        resp = xml.xpath("//Response/Transaction/Processing")
+        resp.children.each do |element|
+          results[element.name.downcase.to_sym] = element.text
+        end
+        results
+      end
+
+      def commit(xml)
+        url = (test? ? test_url : live_url)
+        headers = {
+          'Content-Type' => 'application/x-www-form-urlencoded;charset=UTF-8'
+        }
+
+        response = parse(ssl_post(url, post_data(xml), headers))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          test: test?
+        )
+      end
+
+      def success_from(response)
+        response[:result] == 'ACK'
+      end
+
+      def message_from(response)
+        response[:return]
+      end
+
+      def authorization_from(response)
+        response[:uniqueid]
+      end
+
+      def post_data(xml)
+        "load=#{xml}"
+      end
+
+      def build_xml_request
+        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+          xml.Request(version: '1.0') do
+            xml.Header do
+              xml.Security(sender: @options[:sender])
+            end
+            xml.Transaction(mode: @options[:mode] || 'LIVE', channel: @options[:channel]) do
+              xml.User(login: @options[:login], pwd: @options[:password])
+              yield(xml)
+            end
+          end
+        end
+
+        builder.to_xml
+      end
+    end
+  end
+end

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

@@ -138,6 +138,13 @@ module ActiveMerchant #:nodoc:
         commit(:unstore, post)
       end
 
+      def verify(credit_card, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
       private
       def add_reference(post, identification)
         order_id, transaction_id, authorization, security_key = identification.split(';')
@@ -390,4 +397,3 @@ module ActiveMerchant #:nodoc:
 
   end
 end
-

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

@@ -203,7 +203,7 @@ module ActiveMerchant #:nodoc:
         add_merchant_key(xml, options)
         xml.tag! 'METHOD', 'CC'
         xml.tag! 'NOTE', options[:description] if options[:description]
-        xml.tag! 'ORDERID', options[:order_id]
+        xml.tag! 'ORDERID', truncate(options[:order_id], 25)
         xml.tag! 'OVERRIDE_FROM', 0 # Docs say not required, but doesn't work without it
       end
 

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

@@ -49,7 +49,6 @@ module ActiveMerchant #:nodoc:
         requires!(options, :login)
         @api_key = options[:login]
         @fee_refund_api_key = options[:fee_refund_login]
-        @version = options[:version]
 
         super
       end
@@ -110,6 +109,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_amount(post, money, options)
         post[:refund_application_fee] = true if options[:refund_application_fee]
+        post[:reverse_transfer] = options[:reverse_transfer] if options[:reverse_transfer]
 
         MultiResponse.run(:first) do |r|
           r.process { commit(:post, "charges/#{CGI.escape(identification)}/refund", post, options) }
@@ -123,7 +123,7 @@ module ActiveMerchant #:nodoc:
 
       def verify(payment, options = {})
         MultiResponse.run(:use_first_response) do |r|
-          r.process { authorize(50, payment, options) }
+          r.process { authorize(50, payment, options.merge(currency: "USD")) }
           r.process(:ignore_result) { void(r.authorization, options) }
         end
       end
@@ -243,7 +243,7 @@ module ActiveMerchant #:nodoc:
           add_customer_data(post, options)
           add_metadata(post, options)
           post[:description] = options[:description]
-          post[:statement_description] = options[:statement_description]
+          post[:statement_descriptor] = options[:statement_description]
           add_customer(post, payment, options)
           add_flags(post, options)
         end
@@ -381,20 +381,23 @@ module ActiveMerchant #:nodoc:
 
       def headers(options = {})
         key     = options[:key] || @api_key
-        version = options[:version] || @version
         idempotency_key = options[:idempotency_key]
 
         headers = {
           "Authorization" => "Basic " + Base64.encode64(key.to_s + ":").strip,
           "User-Agent" => "Stripe/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          "Stripe-Version" => api_version(options),
           "X-Stripe-Client-User-Agent" => user_agent,
           "X-Stripe-Client-User-Metadata" => {:ip => options[:ip]}.to_json
         }
-        headers.merge!("Stripe-Version" => version) if version
         headers.merge!("Idempotency-Key" => idempotency_key) if idempotency_key
         headers
       end
 
+      def api_version(options)
+        options[:version] || @options[:version] || "2015-04-07"
+      end
+
       def api_request(method, endpoint, parameters = nil, options = {})
         raw_response = response = nil
         begin

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

@@ -178,7 +178,8 @@ module ActiveMerchant #:nodoc:
           post[:card]   = credit_card.number
           post[:cvv2]   = credit_card.verification_value if credit_card.verification_value?
           post[:expir]  = expdate(credit_card)
-          post[:name]   = credit_card.name
+          post[:name]   = credit_card.name unless credit_card.name.blank?
+          post[:cardpresent] = true if credit_card.manual_entry
         end
       end
 
@@ -256,4 +257,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-

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

@@ -0,0 +1,280 @@
+require 'nokogiri'
+
+module ActiveMerchant
+  module Billing
+    class VancoGateway < Gateway
+      include Empty
+
+      self.test_url = 'https://www.vancodev.com/cgi-bin/wstest2.vps'
+      self.live_url = 'https://www.vancoservices.com/cgi-bin/ws2.vps'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'http://vancopayments.com/'
+      self.display_name = 'Vanco Payment Solutions'
+
+      def initialize(options={})
+        requires!(options, :user_id, :password, :client_id)
+        super
+      end
+
+      def purchase(money, payment_method, options={})
+        MultiResponse.run do |r|
+          r.process { commit(login_request) }
+          r.process { commit(purchase_request(money, payment_method, r.params["response_sessionid"], options)) }
+        end
+      end
+
+      def refund(money, authorization, options={})
+        MultiResponse.run do |r|
+          r.process { commit(login_request) }
+          r.process { commit(refund_request(money, authorization, r.params["response_sessionid"])) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<Password>).+(</Password>))i, '\1[FILTERED]\2').
+          gsub(%r((<CardCVV2>).+(</CardCVV2>))i, '\1[FILTERED]\2').
+          gsub(%r((<AccountNumber>).+(</AccountNumber>))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(xml)
+        doc.root.xpath('*').each do |node|
+          if (node.elements.empty?)
+            response[node.name.downcase.to_sym] = node.text
+          else
+            node.elements.each do |childnode|
+              childnode_to_response(response, node, childnode)
+            end
+          end
+        end
+
+        response
+      end
+
+      def childnode_to_response(response, node, childnode)
+        name = "#{node.name.downcase}_#{childnode.name.downcase}"
+        if name == "response_errors" && !childnode.elements.empty?
+          add_errors_to_response(response, childnode.to_s)
+        else
+          response[name.downcase.to_sym] = childnode.text
+        end
+      end
+
+      def add_errors_to_response(response, errors_xml)
+        errors_hash = Hash.from_xml(errors_xml).values.first
+        response[:response_errors] = errors_hash
+
+        error = errors_hash["Error"]
+        if error.kind_of?(Hash)
+          response[:error_message] = error["ErrorDescription"]
+          response[:error_codes] = error["ErrorCode"]
+        elsif error.kind_of?(Array)
+          error_str = error.map { |e| e["ErrorDescription"]}.join(". ")
+          error_codes = error.map { |e| e["ErrorCode"]}.join(", ")
+          response[:error_message] = "#{error_str}."
+          response[:error_codes] = error_codes
+        end
+      end
+
+      def commit(request)
+        response = parse(ssl_post(url, request, headers))
+
+        succeeded = success_from(response)
+        Response.new(
+          succeeded,
+          message_from(succeeded, response),
+          response,
+          authorization: authorization_from(response),
+          test: test?
+        )
+      end
+
+      def success_from(response)
+        !response[:response_errors]
+      end
+
+      def message_from(succeeded, response)
+        return "Success" if succeeded
+        response[:error_message]
+      end
+
+      def authorization_from(response)
+        [
+          response[:response_customerref],
+          response[:response_paymentmethodref],
+          response[:response_transactionref]
+        ].join("|")
+      end
+
+      def split_authorization(authorization)
+        authorization.to_s.split('|')
+      end
+
+      def purchase_request(money, payment_method, session_id, options)
+        build_xml_request do |doc|
+          add_auth(doc, "EFTAddCompleteTransaction", session_id)
+
+          doc.Request do
+            doc.RequestVars do
+              add_client_id(doc)
+              add_amount(doc, money, options)
+              add_payment_method(doc, payment_method, options)
+              add_purchase_noise(doc)
+            end
+          end
+        end
+      end
+
+      def refund_request(money, authorization, session_id)
+        build_xml_request do |doc|
+          add_auth(doc, "EFTAddCredit", session_id)
+
+          doc.Request do
+            doc.RequestVars do
+              add_client_id(doc)
+              add_amount(doc, money, options)
+              add_reference(doc, authorization)
+              add_refund_noise(doc)
+            end
+          end
+        end
+      end
+
+      def add_request(doc, request_type)
+        doc.RequestType(request_type)
+        doc.RequestID(SecureRandom.hex(15))
+        doc.RequestTime(Time.now)
+        doc.Version(2)
+      end
+
+      def add_auth(doc, request_type, session_id)
+        doc.Auth do
+          add_request(doc, request_type)
+          doc.SessionID(session_id)
+        end
+      end
+
+      def add_reference(doc, authorization)
+        customer_ref, payment_method_ref, transaction_ref = split_authorization(authorization)
+        doc.CustomerRef(customer_ref)
+        doc.PaymentMethodRef(payment_method_ref)
+        doc.TransactionRef(transaction_ref)
+      end
+
+      def add_amount(doc, money, options)
+        if empty?(options[:fund_id])
+          doc.Amount(amount(money))
+        else
+          doc.Funds do
+            doc.Fund do
+              doc.FundID(options[:fund_id])
+              doc.FundAmount(amount(money))
+            end
+          end
+        end
+      end
+
+      def add_payment_method(doc, payment_method, options)
+        if card_brand(payment_method) == 'check'
+          add_echeck(doc, payment_method)
+        else
+          add_credit_card(doc, payment_method, options)
+        end
+      end
+
+      def add_credit_card(doc, credit_card, options)
+        address = options[:billing_address]
+
+        doc.AccountNumber(credit_card.number)
+        doc.CustomerName("#{credit_card.last_name}, #{credit_card.first_name}")
+        doc.CardExpMonth(format(credit_card.month, :two_digits))
+        doc.CardExpYear(format(credit_card.year, :two_digits))
+        doc.CardCVV2(credit_card.verification_value)
+        doc.CardBillingName(credit_card.name)
+        doc.CardBillingAddr1(address[:address1])
+        doc.CardBillingAddr2(address[:address2])
+        doc.CardBillingCity(address[:city])
+        doc.CardBillingState(address[:state])
+        doc.CardBillingZip(address[:zip])
+        doc.CardBillingCountryCode(address[:country])
+        doc.AccountType("CC")
+      end
+
+      def add_echeck(doc, echeck)
+        if echeck.account_type == "savings"
+          doc.AccountType("S")
+        else
+          doc.AccountType("C")
+        end
+
+        doc.CustomerName("#{echeck.last_name}, #{echeck.first_name}")
+        doc.AccountNumber(echeck.account_number)
+        doc.RoutingNumber(echeck.routing_number)
+        doc.TransactionTypeCode("TEL")
+      end
+
+      def add_purchase_noise(doc)
+        doc.StartDate("0000-00-00")
+        doc.FrequencyCode("O")
+      end
+
+      def add_refund_noise(doc)
+        doc.ContactName("Bilbo Baggins")
+        doc.ContactPhone("1234567890")
+        doc.ContactExtension("None")
+        doc.ReasonForCredit("Refund requested")
+      end
+
+      def add_client_id(doc)
+        doc.ClientID(@options[:client_id])
+      end
+
+      def login_request
+        build_xml_request do |doc|
+          doc.Auth do
+            add_request(doc, "Login")
+          end
+
+          doc.Request do
+            doc.RequestVars do
+              doc.UserID(@options[:user_id])
+              doc.Password(@options[:password])
+            end
+          end
+        end
+      end
+
+      def build_xml_request
+        builder = Nokogiri::XML::Builder.new
+        builder.__send__("VancoWS") do |doc|
+          yield(doc)
+        end
+        builder.to_xml
+      end
+
+      def url
+        (test? ? test_url : live_url)
+      end
+
+      def headers
+        {
+          'Content-Type' => 'text/xml'
+        }
+      end
+
+    end
+  end
+end