activemerchant 1.44.1 → 1.45.0

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

@@ -32,6 +32,19 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'https://stripe.com/'
       self.display_name = 'Stripe'
 
+      STANDARD_ERROR_CODE_MAPPING = {
+        'incorrect_number' => STANDARD_ERROR_CODE[:incorrect_number],
+        'invalid_number' => STANDARD_ERROR_CODE[:invalid_number],
+        'invalid_expiry_month' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        'invalid_expiry_year' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        'invalid_cvc' => STANDARD_ERROR_CODE[:invalid_cvc],
+        'expired_card' => STANDARD_ERROR_CODE[:expired_card],
+        'incorrect_cvc' => STANDARD_ERROR_CODE[:incorrect_cvc],
+        'incorrect_zip' => STANDARD_ERROR_CODE[:incorrect_zip],
+        'card_declined' => STANDARD_ERROR_CODE[:card_declined],
+        'processing_error' => STANDARD_ERROR_CODE[:processing_error]
+      }
+
       def initialize(options = {})
         requires!(options, :login)
         @api_key = options[:login]
@@ -41,11 +54,18 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      def authorize(money, creditcard, options = {})
-        post = create_post_for_auth_or_purchase(money, creditcard, options)
-        post[:capture] = "false"
-
-        commit(:post, 'charges', post, options)
+      def authorize(money, payment, options = {})
+        MultiResponse.run do |r|
+          if payment.is_a?(ApplePayPaymentToken)
+            r.process { tokenize_apple_pay_token(payment) }
+            payment = StripePaymentToken.new(r.params["token"]) if r.success?
+          end
+          r.process do |r|
+            post = create_post_for_auth_or_purchase(money, payment, options)
+            post[:capture] = "false"
+            commit(:post, 'charges', post, options)
+          end
+        end.responses.last
       end
 
       # To create a charge on a card or a token, call
@@ -55,10 +75,17 @@ module ActiveMerchant #:nodoc:
       # To create a charge on a customer, call
       #
       #   purchase(money, nil, { :customer => id, ... })
-      def purchase(money, creditcard, options = {})
-        post = create_post_for_auth_or_purchase(money, creditcard, options)
-
-        commit(:post, 'charges', post, options)
+      def purchase(money, payment, options = {})
+        MultiResponse.run do |r|
+          if payment.is_a?(ApplePayPaymentToken)
+            r.process { tokenize_apple_pay_token(payment) }
+            payment = StripePaymentToken.new(r.params["token"]) if r.success?
+          end
+          r.process do |r|
+            post = create_post_for_auth_or_purchase(money, payment, options)
+            commit(:post, 'charges', post, options)
+          end
+        end.responses.last
       end
 
       def capture(money, authorization, options = {})
@@ -88,9 +115,9 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def verify(creditcard, options = {})
+      def verify(payment, options = {})
         MultiResponse.run(:use_first_response) do |r|
-          r.process { authorize(50, creditcard, options) }
+          r.process { authorize(50, payment, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
         end
       end
@@ -113,10 +140,17 @@ module ActiveMerchant #:nodoc:
       end
 
       # Note: creating a new credit card will not change the customer's existing default credit card (use :set_default => true)
-      def store(creditcard, options = {})
-        post = {}
+      def store(payment, options = {})
         card_params = {}
-        add_creditcard(card_params, creditcard, options)
+        post = {}
+
+        if payment.is_a?(ApplePayPaymentToken)
+          token_exchange_response = tokenize_apple_pay_token(payment)
+          card_params = { card: token_exchange_response.params["token"]["id"] } if token_exchange_response.success?
+        else
+          add_creditcard(card_params, payment, options)
+        end
+
         post[:description] = options[:description] if options[:description]
         post[:email] = options[:email] if options[:email]
 
@@ -146,24 +180,56 @@ module ActiveMerchant #:nodoc:
         commit(:post, "customers/#{CGI.escape(customer_id)}", options, options)
       end
 
-      def unstore(customer_id, card_id = nil, options = {})
-        if card_id.nil?
+      def unstore(customer_id, options = {}, deprecated_options = {})
+        if options.kind_of?(String)
+          ActiveMerchant.deprecated "Passing the card_id as the 2nd parameter is deprecated. Put it in the options hash instead."
+          options = deprecated_options.merge(card_id: options)
+        end
+
+        if options[:card_id]
+          commit(:delete, "customers/#{CGI.escape(customer_id)}/cards/#{CGI.escape(options[:card_id])}", nil, options)
+        else
           commit(:delete, "customers/#{CGI.escape(customer_id)}", nil, options)
+        end
+      end
+
+      def tokenize_apple_pay_token(apple_pay_payment_token, options = {})
+        token_response = api_request(:post, "tokens?pk_token=#{CGI.escape(apple_pay_payment_token.payment_data.to_json)}")
+        success = !token_response.key?("error")
+
+        if success && token_response.key?("id")
+          Response.new(success, nil, token: token_response)
         else
-          commit(:delete, "customers/#{CGI.escape(customer_id)}/cards/#{CGI.escape(card_id)}", nil, options)
+          Response.new(success, token_response["error"]["message"])
         end
       end
 
       private
 
-      def create_post_for_auth_or_purchase(money, creditcard, options)
+      class StripePaymentToken < PaymentToken
+        def type
+          'stripe'
+        end
+      end
+
+      def create_post_for_auth_or_purchase(money, payment, options)
         post = {}
         add_amount(post, money, options, true)
-        add_creditcard(post, creditcard, options)
-        add_customer(post, creditcard, options)
-        add_customer_data(post,options)
+        if payment.is_a?(StripePaymentToken)
+          add_payment_token(post, payment, options)
+        else
+          add_creditcard(post, payment, options)
+        end
+        add_customer(post, payment, options)
+        add_customer_data(post, options)
         post[:description] = options[:description]
-        post[:metadata] = { email: options[:email] } if options[:email]
+        post[:statement_description] = options[:statement_description]
+
+        post[:metadata] = {}
+        post[:metadata][:email] = options[:email] if options[:email]
+        post[:metadata][:order_id] = options[:order_id] if options[:order_id]
+        post.delete(:metadata) if post[:metadata].empty?
+
         add_flags(post, options)
         add_application_fee(post, options)
         post
@@ -228,8 +294,12 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_customer(post, creditcard, options)
-        post[:customer] = options[:customer] if options[:customer] && !creditcard.respond_to?(:number)
+      def add_payment_token(post, token, options = {})
+        post[:card] = token.payment_data["id"]
+      end
+
+      def add_customer(post, payment, options)
+        post[:customer] = options[:customer] if options[:customer] && !payment.respond_to?(:number)
       end
 
       def add_flags(post, options)
@@ -280,21 +350,25 @@ module ActiveMerchant #:nodoc:
         headers
       end
 
-      def commit(method, url, parameters=nil, options = {})
-        add_expand_parameters(parameters, options) if parameters
-
+      def api_request(method, endpoint, parameters = nil, options = {})
         raw_response = response = nil
-        success = false
         begin
-          raw_response = ssl_request(method, self.live_url + url, post_data(parameters), headers(options))
+          raw_response = ssl_request(method, self.live_url + endpoint, post_data(parameters), headers(options))
           response = parse(raw_response)
-          success = !response.key?("error")
         rescue ResponseError => e
           raw_response = e.response.body
           response = response_error(raw_response)
         rescue JSON::ParserError
           response = json_error(raw_response)
         end
+        response
+      end
+
+      def commit(method, url, parameters = nil, options = {})
+        add_expand_parameters(parameters, options) if parameters
+
+        response = api_request(method, url, parameters, options)
+        success = !response.key?("error")
 
         card = response["card"] || response["active_card"] || {}
         avs_code = AVS_CODE_TRANSLATOR["line1: #{card["address_line1_check"]}, zip: #{card["address_zip_check"]}"]
@@ -306,7 +380,8 @@ module ActiveMerchant #:nodoc:
           :test => response.has_key?("livemode") ? !response["livemode"] : false,
           :authorization => success ? response["id"] : response["error"]["charge"],
           :avs_result => { :code => avs_code },
-          :cvv_result => cvc_code
+          :cvv_result => cvc_code,
+          :error_code => success ? nil : STANDARD_ERROR_CODE_MAPPING[response["error"]["code"]]
         )
       end
 

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

@@ -0,0 +1,227 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TnsGateway < Gateway
+      self.display_name = 'TNS'
+      self.homepage_url = 'http://www.tnsi.com/'
+
+      # Testing is partitioned by account.
+      self.live_url = 'https://secure.na.tnspayments.com/api/rest/version/22/'
+
+      self.supported_countries = %w(AR AU BR FR DE HK MX NZ SG GB US)
+
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :maestro, :laser]
+
+      def initialize(options={})
+        requires!(options, :userid, :password)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        MultiResponse.run do |r|
+          r.process { authorize(amount, payment_method, options) }
+          r.process { capture(amount, r.authorization, options) }
+        end
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = new_post
+        add_invoice(post, amount, options)
+        add_reference(post, *new_authorization)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit('authorize', post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = new_post
+        add_invoice(post, amount, options, :transaction)
+        add_reference(post, *next_authorization(authorization))
+        add_customer_data(post, options)
+
+        commit('capture', post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = new_post
+        add_invoice(post, amount, options, :transaction)
+        add_reference(post, *next_authorization(authorization))
+        add_customer_data(post, options)
+
+        commit('refund', post)
+      end
+
+      def void(authorization, options={})
+        post = new_post
+        add_reference(post, *next_authorization(authorization), :targetTransactionId)
+
+        commit('void', 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 new_post
+        {
+          order: {},
+          sourceOfFunds: {
+            provided: {
+              card: {
+              }
+            }
+          },
+          customer: {},
+          billing: {},
+          shipping: {},
+          transaction: {},
+        }
+      end
+
+      def add_invoice(post, amount, options, node=:order)
+        post[node][:amount] = amount(amount)
+        post[node][:currency] = (options[:currency] || currency(amount))
+      end
+
+      def add_reference(post, orderid, transactionid, transaction_reference, reference_key=:reference)
+        post[:orderid] = orderid
+        post[:transactionid] = transactionid
+        post[:transaction][reference_key] = transaction_reference if transaction_reference
+      end
+
+      def add_payment_method(post, payment_method)
+        card = {}
+        card[:expiry] = {}
+        card[:number] = payment_method.number
+        card[:securityCode] = payment_method.verification_value
+        card[:expiry][:year] = format(payment_method.year, :two_digits)
+        card[:expiry][:month] = format(payment_method.month, :two_digits)
+
+        post[:sourceOfFunds][:type] = 'CARD'
+        post[:sourceOfFunds][:provided][:card].merge!(card)
+      end
+
+      def add_customer_data(post, options)
+        billing = {}
+        shipping = {}
+        customer = {}
+        if(billing_address = (options[:billing_address] || options[:address]))
+          billing[:address] = {}
+          billing[:address][:street]        = billing_address[:address1]
+          billing[:address][:street2]       = billing_address[:address2]
+          billing[:address][:city]          = billing_address[:city]
+          billing[:address][:stateProvince] = billing_address[:state]
+          billing[:address][:postcodeZip]   = billing_address[:zip]
+          billing[:address][:country]       = billing_address[:country]
+          billing[:phone]                   = billing_address[:phone]
+
+          customer[:email]                  = options[:email] if options[:email]
+          customer[:ipaddress]              = options[:ip] if options[:ip]
+        end
+
+        if(shipping_address = options[:shipping_address])
+          shipping[:address] = {}
+          shipping[:address][:street]        = shipping_address[:address1]
+          shipping[:address][:street2]       = shipping_address[:address2]
+          shipping[:address][:city]          = shipping_address[:city]
+          shipping[:address][:stateProvince] = shipping_address[:state]
+          shipping[:address][:postcodeZip]   = shipping_address[:zip]
+          shipping[:address][:shipcountry]   = shipping_address[:country]
+
+          last_name, first_middle_names = split_name(shipping_address[:name])
+          shipping[:firstName]  = first_middle_names if first_middle_names
+          shipping[:lastName]   = last_name if last_name
+        end
+        post[:billing].merge!(billing)
+        post[:shipping].merge!(shipping)
+        post[:customer].merge!(customer)
+      end
+
+      def commit(action, post)
+        url = build_url(post.delete(:orderid), post.delete(:transactionid))
+        headers = {
+          'Authorization' => 'Basic ' + Base64.encode64("merchant.#{@options[:userid]}:#{@options[:password]}").strip.delete("\r\n"),
+          'Content-Type' => 'application/json',
+        }
+        post[:apiOperation] = action.upcase
+        raw = parse(ssl_request(:put, url, build_request(post), headers))
+
+        succeeded = success_from(raw['result'])
+        Response.new(
+          succeeded,
+          message_from(succeeded, raw),
+          raw,
+          :authorization => authorization_from(post, raw),
+          :test => test?
+        )
+      end
+
+      def build_url(orderid, transactionid)
+        "#{live_url}merchant/#{@options[:userid]}/order/#{orderid}/transaction/#{transactionid}"
+      end
+
+      def build_request(post = {})
+        post.to_json
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(response)
+        response == 'SUCCESS'
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          'Succeeded'
+        else
+          [
+            response['result'],
+            response['response'] && response['response']['gatewayCode'],
+            response['error'] && response['error']['cause'],
+            response['error'] && response['error']['explanation']
+          ].compact.join(' - ')
+        end
+      end
+
+      def authorization_from(request, response)
+        [response['order']['id'], response['transaction']['id']].join('|') if response['order']
+      end
+
+      def split_authorization(authorization)
+        authorization.split('|')
+      end
+
+      def new_authorization
+        # Must be unique within a merchant id.
+        orderid = SecureRandom.uuid
+
+        # Must be unique within an order id.
+        transactionid = '1'
+
+        # New transactions have no previous reference.
+        transaction_reference = nil
+        [orderid, transactionid, transaction_reference]
+      end
+
+      def next_authorization(authorization)
+        orderid, prev_transactionid = split_authorization(authorization)
+        next_transactionid = SecureRandom.uuid
+        [orderid, next_transactionid, prev_transactionid]
+      end
+
+      def split_name(full_name)
+        return nil unless full_name
+        names = full_name.split
+        [names.pop, names.join(' ')]
+      end
+    end
+  end
+end

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

@@ -18,6 +18,25 @@ module ActiveMerchant #:nodoc:
         :void           => 'cc:void'
       }
 
+      STANDARD_ERROR_CODE_MAPPING = {
+        '00011' => STANDARD_ERROR_CODE[:incorrect_number],
+        '00012' => STANDARD_ERROR_CODE[:incorrect_number],
+        '00013' => STANDARD_ERROR_CODE[:incorrect_number],
+        '00014' => STANDARD_ERROR_CODE[:invalid_number],
+        '00015' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '00016' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '00017' => STANDARD_ERROR_CODE[:expired_card],
+        '10116' => STANDARD_ERROR_CODE[:incorrect_cvc],
+        '10107' => STANDARD_ERROR_CODE[:incorrect_zip],
+        '10109' => STANDARD_ERROR_CODE[:incorrect_address],
+        '10110' => STANDARD_ERROR_CODE[:incorrect_address],
+        '10111' => STANDARD_ERROR_CODE[:incorrect_address],
+        '10127' => STANDARD_ERROR_CODE[:card_declined],
+        '10128' => STANDARD_ERROR_CODE[:processing_error],
+        '10132' => STANDARD_ERROR_CODE[:processing_error],
+        '00043' => STANDARD_ERROR_CODE[:call_issuer]
+      }
+
       def initialize(options = {})
         requires!(options, :login)
         super
@@ -29,8 +48,10 @@ module ActiveMerchant #:nodoc:
         add_amount(post, money)
         add_invoice(post, options)
         add_credit_card(post, credit_card)
-        add_address(post, credit_card, options)
-        add_customer_data(post, options)
+        unless credit_card.track_data.present?
+          add_address(post, credit_card, options)
+          add_customer_data(post, options)
+        end
         add_split_payments(post, options)
 
         commit(:authorization, post)
@@ -42,8 +63,10 @@ module ActiveMerchant #:nodoc:
         add_amount(post, money)
         add_invoice(post, options)
         add_credit_card(post, credit_card)
-        add_address(post, credit_card, options)
-        add_customer_data(post, options)
+        unless credit_card.track_data.present?
+          add_address(post, credit_card, options)
+          add_customer_data(post, options)
+        end
         add_split_payments(post, options)
 
         commit(:purchase, post)
@@ -146,10 +169,15 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_credit_card(post, credit_card)
-        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
+        if credit_card.track_data.present?
+          post[:magstripe] = credit_card.track_data
+          post[:cardpresent] = true
+        else
+          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
+        end
       end
 
       # see: http://wiki.usaepay.com/developer/transactionapi#split_payments
@@ -194,12 +222,12 @@ module ActiveMerchant #:nodoc:
       def commit(action, parameters)
         url = (test? ? self.test_url : self.live_url)
         response = parse(ssl_post(url, post_data(action, parameters)))
-
         Response.new(response[:status] == 'Approved', message_from(response), response,
           :test           => test?,
           :authorization  => response[:ref_num],
           :cvv_result     => response[:cvv2_result_code],
-          :avs_result     => { :code => response[:avs_result_code] }
+          :avs_result     => { :code => response[:avs_result_code] },
+          :error_code     => STANDARD_ERROR_CODE_MAPPING[response[:error_code]]
         )
       end