activemerchant 1.29.1 → 1.34.0

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

@@ -1,5 +1,3 @@
-require 'json'
-
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class StripeGateway < Gateway
@@ -35,6 +33,14 @@ module ActiveMerchant #:nodoc:
         super
       end
 
+      def authorize(money, creditcard, options = {})
+        post = create_post_for_auth_or_purchase(money, creditcard, options)
+        post[:capture] = "false"
+        meta = generate_meta(options)
+
+        commit(:post, 'charges', post, meta)
+      end
+
       # To create a charge on a card or a token, call
       #
       #   purchase(money, card_hash_or_token, { ... })
@@ -43,22 +49,20 @@ module ActiveMerchant #:nodoc:
       #
       #   purchase(money, nil, { :customer => id, ... })
       def purchase(money, creditcard, options = {})
-        post = {}
-
-        add_amount(post, money, options)
-        add_creditcard(post, creditcard, options)
-        add_customer(post, options)
-        add_customer_data(post,options)
-        post[:description] = options[:description] || options[:email]
-        add_flags(post, options)
-
+        post = create_post_for_auth_or_purchase(money, creditcard, options)
         meta = generate_meta(options)
 
-        raise ArgumentError.new("Customer or Credit Card required.") if !post[:card] && !post[:customer]
-
         commit(:post, 'charges', post, meta)
       end
 
+      def capture(money, authorization, options = {})
+        post = {}
+        post[:amount] = amount(money)
+        add_application_fee(post, options)
+
+        commit(:post, "charges/#{CGI.escape(authorization)}/capture", post)
+      end
+
       def void(identification, options = {})
         commit(:post, "charges/#{CGI.escape(identification)}/refund", {})
       end
@@ -100,11 +104,27 @@ module ActiveMerchant #:nodoc:
 
       private
 
+      def create_post_for_auth_or_purchase(money, creditcard, options)
+        post = {}
+        add_amount(post, money, options)
+        add_creditcard(post, creditcard, options)
+        add_customer(post, options)
+        add_customer_data(post,options)
+        post[:description] = options[:description] || options[:email]
+        add_flags(post, options)
+        add_application_fee(post, options)
+        post
+      end
+
       def add_amount(post, money, options)
         post[:amount] = amount(money)
         post[:currency] = (options[:currency] || currency(money)).downcase
       end
 
+      def add_application_fee(post, options)
+        post[:application_fee] = options[:application_fee] if options[:application_fee]
+      end
+
       def add_customer_data(post, options)
         metadata_options = [:description,:browser_ip,:user_agent,:referrer]
         post.update(options.slice(*metadata_options))
@@ -126,19 +146,27 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_creditcard(post, creditcard, options)
+        card = {}
         if creditcard.respond_to?(:number)
-          card = {}
-          card[:number] = creditcard.number
-          card[:exp_month] = creditcard.month
-          card[:exp_year] = creditcard.year
-          card[:cvc] = creditcard.verification_value if creditcard.verification_value?
-          card[:name] = creditcard.name if creditcard.name
-          post[:card] = card
+          if creditcard.respond_to?(:track_data) && creditcard.track_data.present?
+            card[:swipe_data] = creditcard.track_data
+          else
+            card[:number] = creditcard.number
+            card[:exp_month] = creditcard.month
+            card[:exp_year] = creditcard.year
+            card[:cvc] = creditcard.verification_value if creditcard.verification_value?
+            card[:name] = creditcard.name if creditcard.name
+          end
 
           add_address(post, options)
         elsif creditcard.kind_of?(String)
-          post[:card] = creditcard
+          if options[:track_data]
+            card[:swipe_data] = options[:track_data]
+          else
+            card[:number] = creditcard
+          end
         end
+        post[:card] = card
       end
 
       def add_customer(post, options)

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

@@ -0,0 +1,239 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TransnationalGateway < Gateway
+      self.live_url = self.test_url = 'https://secure.networkmerchants.com/api/transact.php'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'http://www.tnbci.com/'
+      self.display_name = 'Transnational'
+
+      self.money_format = :dollars
+      self.default_currency = 'USD'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(money, creditcard_or_vault_id, options = {})
+        post = build_auth_post(money, creditcard_or_vault_id, options)
+        commit('auth', post)
+      end
+
+      def purchase(money, creditcard_or_vault_id, options = {})
+        post = build_purchase_post(money, creditcard_or_vault_id, options)
+        commit('sale', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = build_capture_post(money, authorization, options)
+        commit('capture', post)
+      end
+
+      def void(authorization, options = {})
+        post = build_void_post(authorization, options)
+        commit('void', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = build_refund_post(money, authorization, options)
+        commit('refund', post)
+      end
+
+      def store(creditcard, options = {})
+        post = build_store_post(creditcard, options)
+        commit_vault('add_customer', post)
+      end
+
+      def unstore(customer_vault_id, options = {})
+        post = build_unstore_post(customer_vault_id, options)
+        commit_vault('delete_customer', post)
+      end
+
+      private
+
+      def build_auth_post(money, creditcard_or_vault_id, options)
+        post = {}
+        add_order(post, options)
+        add_address(post, options)
+        add_shipping_address(post, options)
+        add_payment_method(post, creditcard_or_vault_id, options)
+        add_amount(post, money)
+        post
+      end
+
+      def build_purchase_post(money, creditcard, options)
+        build_auth_post(money, creditcard, options)
+      end
+
+      def build_capture_post(money, authorization, option)
+        post = {}
+        post[:transactionid] = authorization
+        add_amount(post, money)
+        post
+      end
+
+      def build_void_post(authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        post
+      end
+
+      def build_refund_post(money, authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        add_amount(post, money)
+        post
+      end
+
+      def build_store_post(creditcard_or_check, options)
+        post = {}
+        add_address(post, options)
+        add_shipping_address(post, options)
+        add_payment_method(post, creditcard_or_check, options)
+        post
+      end
+
+      def build_unstore_post(customer_vault_id, options)
+        post = {}
+        post['customer_vault_id'] = customer_vault_id
+        post
+      end
+
+      def add_order(post, options)
+        post[:orderid] = options[:order_id]
+        post[:orderdescription] = options[:description]
+      end
+
+      def add_address(post, options)
+        post[:email] = options[:email]
+        post[:ipaddress] = options[:ip]
+
+        address = options[:billing_address] || options[:address] || {}
+        post[:address1] = address[:address1]
+        post[:address2] = address[:address2]
+        post[:city] = address[:city]
+        post[:state] = address[:state]
+        post[:zip] = address[:zip]
+        post[:country] = address[:country]
+        post[:phone] = address[:phone]
+      end
+
+      def add_shipping_address(post, options)
+        shipping_address = options[:shipping_address] || {}
+        post[:shipping_address1] = shipping_address[:address1]
+        post[:shipping_address2] = shipping_address[:address2]
+        post[:shipping_city] = shipping_address[:city]
+        post[:shipping_state] = shipping_address[:state]
+        post[:shipping_zip] = shipping_address[:zip]
+        post[:shipping_country] = shipping_address[:country]
+      end
+
+      def add_swipe_data(post, options)
+        # unencrypted tracks
+        post[:track_1] = options[:track_1]
+        post[:track_2] = options[:track_2]
+        post[:track_3] = options[:track_3]
+
+        # encrypted tracks
+        post[:magnesafe_track_1] = options[:magnesafe_track_1]
+        post[:magnesafe_track_2] = options[:magnesafe_track_2]
+        post[:magnesafe_track_3] = options[:magnesafe_track_3]
+        post[:magnesafe_magneprint] = options[:magnesafe_magneprint]
+        post[:magnesafe_ksn] = options[:magnesafe_ksn]
+        post[:magnesafe_magneprint_status] = options[:magnesafe_magneprint_status]
+      end
+
+      def add_payment_method(post, creditcard_or_check_or_vault_id, options)
+        post[:processor_id] = options[:processor_id]
+        post[:customer_vault] = 'add_customer' if options[:store]
+
+        add_swipe_data(post, options)
+
+        # creditcard_or_check can be blank if using swipe data
+        if creditcard_or_check_or_vault_id.is_a?(CreditCard) # creditcard or check
+          creditcard = creditcard_or_check_or_vault_id
+          post[:firstname] = creditcard.first_name
+          post[:lastname] = creditcard.last_name
+          post[:ccnumber] = creditcard.number
+          post[:ccexp] = format(creditcard.month, :two_digits) + format(creditcard.year, :two_digits)
+          post[:cvv] = creditcard.verification_value
+          post[:payment] = 'creditcard'
+        elsif creditcard_or_check_or_vault_id.is_a?(Check)
+          check = creditcard_or_check_or_vault_id
+          post[:firstname] = check.first_name
+          post[:lastname] = check.last_name
+          post[:checkname] = check.name
+          post[:checkaba] = check.routing_number
+          post[:checkaccount] = check.account_number
+          post[:account_type] = check.account_type
+          post[:account_holder_type] = check.account_holder_type
+          post[:payment] = 'check'
+        else
+          post[:customer_vault_id] = creditcard_or_check_or_vault_id
+        end
+      end
+
+      def add_login(post)
+        post[:username] = @options[:login]
+        post[:password] = @options[:password]
+      end
+
+      def add_amount(post, money)
+        post[:currency] = options[:currency] || currency(money)
+        post[:amount] = amount(money)
+      end
+
+      def commit_vault(action, parameters)
+        commit(nil, parameters.merge(:customer_vault => action))
+      end
+
+      def commit(action, parameters)
+        raw = parse(ssl_post(self.live_url, build_request(action, parameters)))
+
+        success = (raw['response'] == ResponseCodes::APPROVED)
+
+        authorization = authorization_from(success, parameters, raw)
+
+        Response.new(success, raw['responsetext'], raw,
+          :test => test?,
+          :authorization => authorization,
+          :avs_result => { :code => raw['avsresponse']},
+          :cvv_result => raw['cvvresponse']
+        )
+      end
+
+      def build_request(action, parameters)
+        parameters[:type] = action if action
+        add_login(parameters)
+        parameters.to_query
+      end
+
+      def authorization_from(success, parameters, response)
+        return nil unless success
+
+        authorization = response['transactionid']
+        if(parameters[:customer_vault] && (authorization.nil? || authorization.empty?))
+          authorization = response['customer_vault_id']
+        end
+
+        authorization
+      end
+
+      class ResponseCodes
+        APPROVED = '1'
+        DENIED = '2'
+        ERROR = '3'
+      end
+
+      def parse(raw_response)
+        rsp = CGI.parse(raw_response)
+        rsp.keys.each { |k| rsp[k] = rsp[k].first } # flatten out the values
+        rsp
+      end
+    end
+  end
+end
+

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

@@ -174,7 +174,7 @@ module ActiveMerchant #:nodoc:
         :xid => [:string, 'XID'],
         :cavv => [:string, 'CAVV'],
         :eci => [:integer, 'ECI'],
-        :internal_card_authorization => [:boolean, 'InternalCardAduth'],
+        :internal_card_authorization => [:boolean, 'InternalCardAuth'],
         :pares => [:string, 'Pares']
       } #:nodoc:
 
@@ -283,14 +283,19 @@ module ActiveMerchant #:nodoc:
         void_transaction(options.merge!(:reference_number => identification))
       end
 
-      # Credit a previous transaction.
+      # Refund a previous transaction.
       #
       # Note: See run_transaction for additional options.
       #
-      def credit(money, identification, options={})
+      def refund(money, identification, options={})
         refund_transaction(options.merge!(:amount => money, :reference_number => identification))
       end
 
+      def credit(money, identification, options={})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, identification, options)
+      end
+
       # Customer ======================================================
 
       # Add a customer.
@@ -1334,7 +1339,7 @@ module ActiveMerchant #:nodoc:
 
       def build_check_data(soap, options)
         soap.CheckData 'xsi:type' => "ns1:CheckData" do |soap|
-          build_tag soap, :string, 'Account', options[:payment_method].number
+          build_tag soap, :string, 'Account', options[:payment_method].account_number
           build_tag soap, :string, 'Routing', options[:payment_method].routing_number
           build_tag soap, :string, 'AccountType', options[:payment_method].account_type.capitalize
           CHECK_DATA_OPTIONS.each do |k,v|

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

@@ -13,6 +13,14 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'https://webpay.jp/'
       self.display_name = 'WebPay'
 
+      def authorize(money, credit_card, options = {})
+        raise NotImplementedError.new
+      end
+
+      def capture(money, credit_card, options = {})
+        raise NotImplementedError.new
+      end
+
       def json_error(raw_response)
         msg = 'Invalid response received from the WebPay API.  Please contact support@webpay.jp if you continue to receive this message.'
         msg += "  (The raw response returned by the API was #{raw_response.inspect})"

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

@@ -16,7 +16,7 @@ module ActiveMerchant #:nodoc:
         'xsi:noNamespaceSchemaLocation' => 'wirecard.xsd'
       }
 
-      PERMITTED_TRANSACTIONS = %w[ AUTHORIZATION CAPTURE_AUTHORIZATION PURCHASE ]
+      PERMITTED_TRANSACTIONS = %w[ PREAUTHORIZATION CAPTURE PURCHASE ]
 
       RETURN_CODES = %w[ ACK NOK ]
 
@@ -63,13 +63,13 @@ module ActiveMerchant #:nodoc:
       # Authorization
       def authorize(money, creditcard, options = {})
         options[:credit_card] = creditcard
-        commit(:authorization, money, options)
+        commit(:preauthorization, money, options)
       end
 
       # Capture Authorization
       def capture(money, authorization, options = {})
-        options[:authorization] = authorization
-        commit(:capture_authorization, money, options)
+        options[:preauthorization] = authorization
+        commit(:capture, money, options)
       end
 
       # Purchase
@@ -148,16 +148,17 @@ module ActiveMerchant #:nodoc:
         options[:order_id] ||= generate_unique_id
 
         xml.tag! "FNC_CC_#{options[:action].to_s.upcase}" do
-          xml.tag! 'FunctionID', options[:description]
+          xml.tag! 'FunctionID', options[:description].to_s.slice(0,32)
           xml.tag! 'CC_TRANSACTION' do
             xml.tag! 'TransactionID', options[:order_id]
             case options[:action]
-            when :authorization, :purchase
+            when :preauthorization, :purchase
               add_invoice(xml, money, options)
               add_creditcard(xml, options[:credit_card])
               add_address(xml, options[:billing_address])
-            when :capture_authorization
-              xml.tag! 'GuWID', options[:authorization]
+            when :capture
+              xml.tag! 'GuWID', options[:preauthorization]
+              add_amount(xml, money)
             end
           end
         end
@@ -165,7 +166,7 @@ module ActiveMerchant #:nodoc:
 
       # Includes the payment (amount, currency, country) to the transaction-xml
       def add_invoice(xml, money, options)
-        xml.tag! 'Amount', amount(money)
+        add_amount(xml, money)
         xml.tag! 'Currency', options[:currency] || currency(money)
         xml.tag! 'CountryCode', options[:billing_address][:country]
         xml.tag! 'RECURRING_TRANSACTION' do
@@ -173,6 +174,11 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      # Include the amount in the transaction-xml
+      def add_amount(xml, money)
+        xml.tag! 'Amount', amount(money)
+      end
+
       # Includes the credit-card data to the transaction-xml
       def add_creditcard(xml, creditcard)
         raise "Creditcard must be supplied!" if creditcard.nil?

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

@@ -16,6 +16,9 @@ module ActiveMerchant #:nodoc:
         'master'           => 'ECMC-SSL',
         'discover'         => 'DISCOVER-SSL',
         'american_express' => 'AMEX-SSL',
+        'jcb'              => 'JCB-SSL',
+        'maestro'          => 'MAESTRO-SSL',
+        'laser'            => 'LASER-SSL'
       }
 
       def initialize(options = {})
@@ -38,6 +41,10 @@ module ActiveMerchant #:nodoc:
       def capture(money, authorization, options = {})
         MultiResponse.run do |r|
           r.process{inquire_request(authorization, options, "AUTHORISED")} unless options[:authorization_validated]
+          if r.params
+            authorization_currency = r.params['amount_currency_code']
+            options = options.merge(:currency => authorization_currency) if authorization_currency.present?
+          end
           r.process{capture_request(money, authorization, options)}
         end
       end
@@ -51,7 +58,7 @@ module ActiveMerchant #:nodoc:
 
       def refund(money, authorization, options = {})
         MultiResponse.run do |r|
-          r.process{inquire_request(authorization, options, "CAPTURED")}
+          r.process{inquire_request(authorization, options, "CAPTURED", "SETTLED")}
           r.process{refund_request(money, authorization, options)}
         end
       end
@@ -70,17 +77,17 @@ module ActiveMerchant #:nodoc:
         commit('cancel', build_void_request(authorization, options), :ok)
       end
 
-      def inquire_request(authorization, options, success_criteria)
-        commit('inquiry', build_order_inquiry_request(authorization, options), success_criteria)
+      def inquire_request(authorization, options, *success_criteria)
+        commit('inquiry', build_order_inquiry_request(authorization, options), *success_criteria)
       end
 
       def refund_request(money, authorization, options)
-        commit('inquiry', build_refund_request(money, authorization, options), :ok)
+        commit('refund', build_refund_request(money, authorization, options), :ok)
       end
 
       def build_request
         xml = Builder::XmlMarkup.new :indent => 2
-        xml.instruct!
+        xml.instruct! :xml, :encoding => 'ISO-8859-1'
         xml.declare! :DOCTYPE, :paymentService, :PUBLIC, "-//WorldPay//DTD WorldPay PaymentService v1//EN", "http://dtd.wp3.rbsworldpay.com/paymentService_v1.dtd"
         xml.tag! 'paymentService', 'version' => "1.4", 'merchantCode' => @options[:login] do
           yield xml
@@ -142,16 +149,26 @@ module ActiveMerchant #:nodoc:
       def build_refund_request(money, authorization, options)
         build_order_modify_request(authorization) do |xml|
           xml.tag! 'refund' do
-            add_amount(xml, money, options)
+            add_amount(xml, money, options.merge(:debit_credit_indicator => "credit"))
           end
         end
       end
 
       def add_amount(xml, money, options)
-        xml.tag! 'amount',
-          :value => amount(money),
-          'currencyCode' => (options[:currency] || currency(money)),
+        currency = options[:currency] || currency(money)
+        amount   = localized_amount(money, currency)
+
+        amount_hash = {
+          :value => amount,
+          'currencyCode' => currency,
           'exponent' => 2
+        }
+
+        if options[:debit_credit_indicator]
+          amount_hash.merge!('debitCreditIndicator' => options[:debit_credit_indicator])
+        end
+
+        xml.tag! 'amount', amount_hash
       end
 
       def add_payment_method(xml, amount, payment_method, options)
@@ -219,20 +236,18 @@ module ActiveMerchant #:nodoc:
         raw
       end
 
-      def commit(action, request, success_criteria)
-        xmr = ssl_post((test? ? self.test_url : self.live_url),
-          request,
-          'Content-Type' => 'text/xml',
-          'Authorization' => encoded_credentials)
-
+      def commit(action, request, *success_criteria)
+        xmr = ssl_post(url, request, 'Content-Type' => 'text/xml', 'Authorization' => encoded_credentials)
         raw = parse(action, xmr)
+        success, message = success_and_message_from(raw, success_criteria)
 
         Response.new(
-          success_from(raw, success_criteria),
-          message_from(raw),
+          success,
+          message,
           raw,
           :authorization => authorization_from(raw),
           :test => test?)
+
       rescue ActiveMerchant::ResponseError => e
         if e.response.code.to_s == "401"
           return Response.new(false, "Invalid credentials", {}, :test => test?)
@@ -241,15 +256,29 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def success_from(raw, success_criteria)
-        (raw[:last_event] == success_criteria ||
-          raw[:ok].present?)
+      def url
+        test? ? self.test_url : self.live_url
       end
 
-      def message_from(raw)
-        (raw[:iso8583_return_code_description] ||
-          raw[:error] ||
-          "SUCCESS")
+      # success_criteria can be:
+      #   - a string or an array of strings (if one of many responses)
+      #   - An array of strings if one of many responses could be considered a
+      #     success.
+      def success_and_message_from(raw, success_criteria)
+        success = (success_criteria.include?(raw[:last_event]) || raw[:ok].present?)
+        if success
+          message = "SUCCESS"
+        else
+          message = (raw[:iso8583_return_code_description] || raw[:error] || required_status_message(raw, success_criteria))
+        end
+
+        [ success, message ]
+      end
+
+      def required_status_message(raw, success_criteria)
+        if(!success_criteria.include?(raw[:last_event]))
+          "A transaction status of #{success_criteria.collect{|c| "'#{c}'"}.join(" or ")} is required."
+        end
       end
 
       def authorization_from(raw)
@@ -261,6 +290,13 @@ module ActiveMerchant #:nodoc:
         credentials = "#{@options[:login]}:#{@options[:password]}"
         "Basic #{[credentials].pack('m').strip}"
       end
+
+      def localized_amount(money, currency)
+        amount = amount(money)
+        return amount unless CURRENCIES_WITHOUT_FRACTIONS.include?(currency.to_s)
+
+        amount.to_i / 100 * 100
+      end
     end
   end
 end

data/lib/active_merchant/billing/integrations/direc_pay/status.rb

@@ -6,7 +6,7 @@ module ActiveMerchant #:nodoc:
         class Status
           include PostsData
                     
-          STATUS_TEST_URL = 'https://test.timesofmoney.com/direcpay/secure/dpPullMerchAtrnDtls.jsp'
+          STATUS_TEST_URL = 'https://test.direcpay.com/direcpay/secure/dpMerchantTransaction.jsp'
           STATUS_LIVE_URL = 'https://www.timesofmoney.com/direcpay/secure/dpPullMerchAtrnDtls.jsp'
           
           attr_reader :account, :options

data/lib/active_merchant/billing/integrations/direc_pay.rb

@@ -10,7 +10,7 @@ module ActiveMerchant #:nodoc:
         mattr_accessor :production_url, :test_url
         
         self.production_url = "https://www.timesofmoney.com/direcpay/secure/dpMerchantTransaction.jsp"
-        self.test_url       = "https://test.timesofmoney.com/direcpay/secure/dpMerchantTransaction.jsp"
+        self.test_url       = "https://test.direcpay.com/direcpay/secure/dpMerchantTransaction.jsp"
 
         def self.service_url
           mode = ActiveMerchant::Billing::Base.integration_mode

data/lib/active_merchant/billing/integrations/dwolla/common.rb

@@ -0,0 +1,23 @@
+require "openssl"
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Dwolla
+        module Common
+          def verify_signature(checkoutId, amount, notification_signature, secret)
+            if secret.nil?
+              raise ArgumentError, "You need to provide the Application secret as the option :credential3 to verify that the notification originated from Dwolla"
+            end
+
+            expected_signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new, secret, "%s&%.2f" % [checkoutId, amount])
+
+            if notification_signature != expected_signature
+              raise StandardError, "Dwolla signature verification failed."
+            end
+          end
+        end
+      end
+    end
+  end
+end