activemerchant 1.32.1 → 1.33.0

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

@@ -34,7 +34,7 @@ module ActiveMerchant #:nodoc:
         money = amount(money)
         case normalize(credit_card_or_reference)
         when /1$/, AUTHORIZATION
-          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true)
+          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true, :authorization => AUTHORIZATION)
         when /2$/
           Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE },:test => true)
         else

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

@@ -0,0 +1,155 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CardStreamModernGateway < Gateway
+      self.test_url = self.live_url = 'https://gateway.cardstream.com/direct/'
+      self.money_format = :cents
+      self.default_currency = 'GBP'
+      self.supported_countries = ['GB']
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :discover, :jcb, :maestro, :solo, :switch]
+      self.homepage_url = 'http://www.cardstream.com/'
+      self.display_name = 'CardStream'
+
+      def initialize(options = {})
+        requires!(options, :login)
+        if(options[:threeDSRequired])
+          @threeDSRequired = options[:threeDSRequired]
+        else
+          @threeDSRequired = 'N'
+        end
+        super
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_amount(post, money, options)
+        add_invoice(post, creditcard, money, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        add_customer_data(post, options)
+        commit('PREAUTH', post)
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_amount(post, money, options)
+        add_invoice(post, creditcard, money, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        add_customer_data(post, options)
+        commit('SALE', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_pair(post, :xref, authorization)
+        add_amount(post, money, options)
+        commit('SALE', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        add_pair(post, :xref, authorization)
+        add_amount(post, money, options)
+        commit('REFUND', post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        add_pair(post, :xref, authorization)
+        commit('REFUND', post)
+      end
+
+      private
+
+      def add_amount(post, money, options)
+        add_pair(post, :amount, amount(money), :required => true)
+        add_pair(post, :currencyCode, options[:currency] || self.default_currency)
+      end
+
+      def add_customer_data(post, options)
+        address = options[:billing_address] || options[:address]
+        add_pair(post, :customerPostCode, address[:zip])
+        add_pair(post, :customerEmail, options[:email])
+        add_pair(post, :customerPhone, options[:phone])
+      end
+
+      def add_address(post, creditcard, options)
+        address = options[:billing_address] || options[:address]
+
+        return if address.nil?
+
+        add_pair(post, :customerAddress, address[:address1] + " " + (address[:address2].nil? ? "" : address[:address2]) )
+        add_pair(post, :customerPostCode, address[:zip])
+      end
+
+      def add_invoice(post, credit_card, money, options)
+        add_pair(post, :transactionUnique, options[:order_id], :required => true)
+        add_pair(post, :orderRef, options[:description] || options[:order_id], :required => true)
+        if [ 'american_express', 'diners_club' ].include?(card_brand(credit_card).to_s)
+          add_pair(post, :item1Quantity,  1)
+          add_pair(post, :item1Description,  (options[:description] || options[:order_id]).slice(0, 15))
+          add_pair(post, :item1GrossValue, amount(money))
+        end
+      end
+
+      def add_creditcard(post, credit_card)
+        add_pair(post, :customerName, credit_card.name, :required => true)
+        add_pair(post, :cardNumber, credit_card.number, :required => true)
+
+        add_pair(post, :cardExpiryMonth, format(credit_card.month, :two_digits), :required => true)
+        add_pair(post, :cardExpiryYear, format(credit_card.year, :two_digits), :required => true)
+
+        if requires_start_date_or_issue_number?(credit_card)
+          add_pair(post, :cardStartMonth, format(credit_card.start_month, :two_digits))
+          add_pair(post, :cardStartYear, format(credit_card.start_year, :two_digits))
+
+          add_pair(post, :cardIssueNumber, credit_card.issue_number)
+        end
+
+        add_pair(post, :cardCVV, credit_card.verification_value)
+      end
+
+      def parse(body)
+        result = {}
+        pairs = body.split("&")
+        pairs.each do |pair|
+          a = pair.split("=")
+          result[a[0].to_sym] = CGI.unescape(a[1])
+        end
+        result
+      end
+
+      def commit(action, parameters)
+        response = parse( ssl_post(self.live_url, post_data(action, parameters)) )
+
+        Response.new(response[:responseCode] == "0",
+          response[:responseCode] == "0" ? "APPROVED" : response[:responseMessage],
+          response,
+          :test => test?,
+          :authorization => response[:xref],
+          :avs_result => {
+            :street_match => response[:addressCheck],
+            :postal_match => response[:postcodeCheck],
+          },
+          :cvv_result => response[:cv2Check]
+        )
+      end
+
+      def post_data(action, parameters = {})
+        parameters.update(
+          :merchantID => @options[:login],
+          :action => action,
+          :type => '1', #Ecommerce
+          :countryCode => self.supported_countries[0],
+          :threeDSRequired => @threeDSRequired #Disable 3d secure by default
+        )
+        parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+
+      def add_pair(post, key, value, options = {})
+        post[key] = value if !value.blank? || options[:required]
+      end
+    end
+  end
+end
+

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

@@ -1,15 +1,17 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class FirstdataE4Gateway < Gateway
-      self.test_url = "https://api.demo.globalgatewaye4.firstdata.com/transaction"
-      self.live_url = "https://api.globalgatewaye4.firstdata.com/transaction"
+      # TransArmor support requires v11 or lower
+      self.test_url = "https://api.demo.globalgatewaye4.firstdata.com/transaction/v11"
+      self.live_url = "https://api.globalgatewaye4.firstdata.com/transaction/v11"
 
       TRANSACTIONS = {
         :sale          => "00",
         :authorization => "01",
         :capture       => "32",
         :void          => "33",
-        :credit        => "34"
+        :credit        => "34",
+        :store         => "05"
       }
 
       POST_HEADERS = {
@@ -44,12 +46,12 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      def authorize(money, credit_card, options = {})
-        commit(:authorization, build_sale_or_authorization_request(money, credit_card, options))
+      def authorize(money, credit_card_or_store_authorization, options = {})
+        commit(:authorization, build_sale_or_authorization_request(money, credit_card_or_store_authorization, options))
       end
 
-      def purchase(money, credit_card, options = {})
-        commit(:sale, build_sale_or_authorization_request(money, credit_card, options))
+      def purchase(money, credit_card_or_store_authorization, options = {})
+        commit(:sale, build_sale_or_authorization_request(money, credit_card_or_store_authorization, options))
       end
 
       def capture(money, authorization, options = {})
@@ -64,6 +66,33 @@ module ActiveMerchant #:nodoc:
         commit(:credit, build_capture_or_credit_request(money, authorization, options))
       end
 
+      # Tokenize a credit card with TransArmor
+      #
+      # The TransArmor token and other card data necessary for subsequent
+      # transactions is stored in the response's +authorization+ attribute.
+      # The authorization string may be passed to +authorize+ and +purchase+
+      # instead of a +ActiveMerchant::Billing::CreditCard+ instance.
+      #
+      # TransArmor support must be explicitly activated on your gateway
+      # account by FirstData. If your authorization string is empty, contact
+      # FirstData support for account setup assistance.
+      #
+      # === Example
+      #
+      #   # Generate token
+      #   result = gateway.store(credit_card)
+      #   if result.success?
+      #     my_record.update_attributes(:authorization => result.authorization)
+      #   end
+      #
+      #   # Use token
+      #   result = gateway.purchase(1000, my_record.authorization)
+      #
+      # https://firstdata.zendesk.com/entries/21303361-transarmor-tokenization
+      def store(credit_card, options = {})
+        commit(:store, build_store_request(credit_card, options), credit_card)
+      end
+
       private
 
       def build_request(action, body)
@@ -79,11 +108,17 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
-      def build_sale_or_authorization_request(money, credit_card, options)
+      def build_sale_or_authorization_request(money, credit_card_or_store_authorization, options)
         xml = Builder::XmlMarkup.new
 
         add_amount(xml, money)
-        add_credit_card(xml, credit_card)
+
+        if credit_card_or_store_authorization.is_a? String
+          add_credit_card_token(xml, credit_card_or_store_authorization)
+        else
+          add_credit_card(xml, credit_card_or_store_authorization)
+        end
+
         add_customer_data(xml, options)
         add_invoice(xml, options)
 
@@ -100,6 +135,15 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
+      def build_store_request(credit_card, options)
+        xml = Builder::XmlMarkup.new
+
+        add_credit_card(xml, credit_card)
+        add_customer_data(xml, options)
+
+        xml.target!
+      end
+
       def add_credentials(xml)
         xml.tag! "ExactID", @options[:login]
         xml.tag! "Password", @options[:password]
@@ -132,6 +176,21 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_credit_card_token(xml, store_authorization)
+        params = store_authorization.split(";")
+        credit_card = CreditCard.new(
+          :brand      => params[1],
+          :first_name => params[2],
+          :last_name  => params[3],
+          :month      => params[4],
+          :year       => params[5])
+
+        xml.tag! "TransarmorToken", params[0]
+        xml.tag! "Expiry_Date", expdate(credit_card)
+        xml.tag! "CardHoldersName", credit_card.name
+        xml.tag! "CardType", credit_card.brand
+      end
+
       def add_customer_data(xml, options)
         xml.tag! "Customer_Ref", options[:customer] if options[:customer]
         xml.tag! "Client_IP", options[:ip] if options[:ip]
@@ -153,7 +212,7 @@ module ActiveMerchant #:nodoc:
         "#{format(credit_card.month, :two_digits)}#{format(credit_card.year, :two_digits)}"
       end
 
-      def commit(action, request)
+      def commit(action, request, credit_card = nil)
         url = (test? ? self.test_url : self.live_url)
         begin
           response = parse(ssl_post(url, build_request(action, request), POST_HEADERS))
@@ -163,7 +222,7 @@ module ActiveMerchant #:nodoc:
 
         Response.new(successful?(response), message_from(response), response,
           :test => test?,
-          :authorization => authorization_from(response),
+          :authorization => response_authorization(action, response, credit_card),
           :avs_result => {:code => response[:avs]},
           :cvv_result => response[:cvv2]
         )
@@ -173,6 +232,14 @@ module ActiveMerchant #:nodoc:
         response[:transaction_approved] == SUCCESS
       end
 
+      def response_authorization(action, response, credit_card)
+        if action == :store
+          store_authorization_from(response, credit_card)
+        else
+          authorization_from(response)
+        end
+      end
+
       def authorization_from(response)
         if response[:authorization_num] && response[:transaction_tag]
           [
@@ -185,6 +252,21 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def store_authorization_from(response, credit_card)
+        if response[:transarmor_token].present?
+          [
+            response[:transarmor_token],
+            credit_card.brand,
+            credit_card.first_name,
+            credit_card.last_name,
+            credit_card.month,
+            credit_card.year
+            ].map { |value| value.to_s.gsub(/;/, "") }.join(";")
+        else
+          raise StandardError, "TransArmor support is not enabled on your #{display_name} account"
+        end
+      end
+
       def money_from_authorization(auth)
         _, _, amount = auth.split(/;/, 3)
         amount.to_i # return the # of cents, no need to divide
@@ -193,7 +275,7 @@ module ActiveMerchant #:nodoc:
       def message_from(response)
         if(response[:faultcode] && response[:faultstring])
           response[:faultstring]
-        elsif(response[:error_number] != "0")
+        elsif(response[:error_number] && response[:error_number] != "0")
           response[:error_description]
         else
           result = (response[:exact_message] || "")

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

@@ -82,13 +82,26 @@ module ActiveMerchant #:nodoc:
       end
 
       def capture(money, authorization, options = {})
-        to_pass = create_capture_hash(money, authorization, options)
+        transaction_id, kind = split_authorization(authorization)
+        to_pass = create_capture_hash(money, transaction_id, options)
         build_response(:capture, @litle.capture(to_pass))
       end
 
+      # Note: Litle requires that authorization requests be voided via auth_reversal
+      # and other requests via void. To maintain the same interface as the other
+      # gateways the transaction_id and the kind of transaction are concatenated
+      # together with a ; separator (e.g. 1234;authorization)
+      #
+      # A partial auth_reversal can be accomplished by passing :amount as an option
       def void(identification, options = {})
-        to_pass = create_void_hash(identification, options)
-        build_response(:void, @litle.void(to_pass))
+        transaction_id, kind = split_authorization(identification)
+        if(kind == 'authorization')
+          to_pass = create_auth_reversal_hash(transaction_id, options[:amount], options)
+          build_response(:authReversal, @litle.auth_reversal(to_pass))
+        else
+          to_pass = create_void_hash(transaction_id, options)
+          build_response(:void, @litle.void(to_pass))
+        end
       end
 
       def credit(money, identification_or_token, options = {})
@@ -142,17 +155,11 @@ module ActiveMerchant #:nodoc:
         if response['response'] == "0"
           detail        = response["#{kind}Response"]
           fraud         = fraud_result(detail)
-          authorization = case kind
-                          when :registerToken
-                            response['registerTokenResponse']['litleToken']
-                          else
-                            detail['litleTxnId']
-                          end
           Response.new(
               valid_responses.include?(detail['response']),
               detail['message'],
               { :litleOnlineResponse => response },
-              :authorization => authorization,
+              :authorization => authorization_from(detail, kind),
               :avs_result    => { :code => fraud['avs'] },
               :cvv_result    => fraud['cvv'],
               :test          => test?
@@ -162,6 +169,22 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      # Generates an authorization string of the appropriate id and the kind of transaction
+      # See #void for how the kind is used
+      def authorization_from(litle_response, kind)
+        case kind
+        when :registerToken
+          authorization = litle_response['litleToken']
+        else
+          authorization = [litle_response['litleTxnId'], kind.to_s].join(";")
+        end
+      end
+
+      def split_authorization(authorization)
+        transaction_id, kind = authorization.to_s.split(';')
+        [transaction_id, kind]
+      end
+
       def build_authorize_request(money, creditcard_or_token, options)
         payment_method = build_payment_method(creditcard_or_token, options)
 
@@ -224,7 +247,8 @@ module ActiveMerchant #:nodoc:
         if identification_or_cardtoken.is_a?(LitleCardToken)
           add_cardtoken_hash(hash, identification_or_cardtoken)
         else
-          hash['litleTxnId'] = identification_or_cardtoken
+          transaction_id, kind = split_authorization(identification_or_cardtoken)
+          hash['litleTxnId'] = transaction_id
         end
       end
 
@@ -274,6 +298,12 @@ module ActiveMerchant #:nodoc:
         hash
       end
 
+      def create_auth_reversal_hash(identification, money, options)
+        hash               = create_hash(money, options)
+        hash['litleTxnId'] = identification
+        hash
+      end
+
       def create_hash(money, options)
         fraud_check_type = {}
         if options[:ip]

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

@@ -23,6 +23,8 @@ module ActiveMerchant #:nodoc:
 
       def authorize(money, creditcard_or_card_id, options = {})
         post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        post[:moto_ecommerce_ind] = options[:moto_ecommerce_ind] if options.has_key?(:moto_ecommerce_ind)
         add_invoice(post, options)
         add_payment_source(post, creditcard_or_card_id, options)
         add_address(post, options)
@@ -31,6 +33,8 @@ module ActiveMerchant #:nodoc:
 
       def purchase(money, creditcard_or_card_id, options = {})
         post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        post[:moto_ecommerce_ind] = options[:moto_ecommerce_ind] if options.has_key?(:moto_ecommerce_ind)
         add_invoice(post, options)
         add_payment_source(post, creditcard_or_card_id, options)
         add_address(post, options)
@@ -40,33 +44,48 @@ module ActiveMerchant #:nodoc:
       def capture(money, transaction_id, options = {})
         post ={}
         post[:transaction_id] = transaction_id
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
         commit('S', money, post)
       end
 
       def store(creditcard, options = {})
         post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
         add_creditcard(post, creditcard, options)
         commit('T', nil, post)
       end
 
       def unstore(card_id)
         post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
         post[:card_id] = card_id
         commit('X', nil, post)
       end
 
       def refund(money, identification, options = {})
-        commit('U', money, options.merge(:transaction_id => identification))
+        post = {}
+        post[:transaction_id] = identification
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        options.delete(:customer)
+        options.delete(:billing_address)
+        commit('U', money, options.merge(post))
       end
 
       def credit(money, creditcard_or_card_id, options = {})
         post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        add_invoice(post, options)
         add_payment_source(post, creditcard_or_card_id, options)
         commit('C', money, post)
       end
 
       def void(transaction_id, options = {})
-        commit('V', nil, options.merge(:transaction_id => transaction_id))
+        post = {}
+        post[:transaction_id] = transaction_id
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        options.delete(:customer)
+        options.delete(:billing_address)
+        commit('V', nil, options.merge(post))
       end
 
       private
@@ -111,11 +130,15 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, money, parameters)
-
         url = test? ? self.test_url : self.live_url
         parameters[:transaction_amount]  = amount(money) if money unless action == 'V'
 
-        response = parse( ssl_post(url, post_data(action,parameters)) )
+
+        response = begin
+          parse( ssl_post(url, post_data(action,parameters)) )
+        rescue ActiveMerchant::ResponseError => e
+          { "error_code" => "404",  "auth_response_text" => e.to_s }
+        end
 
         Response.new(response["error_code"] == "000", message_from(response), response,
           :authorization => response["transaction_id"],
@@ -123,7 +146,6 @@ module ActiveMerchant #:nodoc:
           :cvv_result => response["cvv2_result"],
           :avs_result => { :code => response["avs_result"] }
         )
-
       end
 
       def expdate(creditcard)
@@ -152,4 +174,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-