activemerchant 1.38.0 → 1.78.0

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

@@ -1,55 +1,108 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-    #
-    # CardStream supports the following credit cards, which are auto-detected by
-    # the gateway based on the card number used:
-    # * AM American Express
-    # * Diners Club
-    # * Electron
-    # * JCB
-    # * UK Maestro
-    # * Maestro International
-    # * Mastercard
-    # * Solo
-    # * Style
-    # * Switch
-    # * Visa Credit
-    # * Visa Debit
-    # * Visa Purchasing
-    #
     class CardStreamGateway < Gateway
-      self.live_url = self.test_url = 'https://gateway.cardstream.com/process.ashx'
 
+      THREEDSECURE_REQUIRED_DEPRECATION_MESSAGE = "Specifying the :threeDSRequired initialization option is deprecated. Please use the `:threeds_required => true` *transaction* option instead."
+
+      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_countries = ['GB', 'US', 'CH', 'SE', 'SG', 'NO', 'JP', 'IS', 'HK', 'NL', 'CZ', 'CA', 'AU']
       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'
 
-      APPROVED = '00'
-
       CURRENCY_CODES = {
-        "AUD"=> '036',
-        "CAD"=> '124',
-        "CZK"=> '203',
-        "DKK"=> '208',
-        "HKD"=> '344',
-        "ICK"=> '352',
-        "JPY"=> '392',
-        "NOK"=> '578',
-        "SGD"=> '702',
-        "SEK"=> '752',
-        "CHF"=> '756',
-        "GBP"=> '826',
-        "USD"=> '840',
-        "EUR"=> '978'
-      }
-
-      TRANSACTIONS = {
-        :purchase => 'ESALE_KEYED',
-        :refund => 'EREFUND_KEYED',
-        :authorization => 'ESALE_KEYED'
+        "AED" => "784",
+        "ALL" => "008",
+        "AMD" => "051",
+        "ANG" => "532",
+        "ARS" => "032",
+        "AUD" => "036",
+        "AWG" => "533",
+        "BAM" => "977",
+        "BBD" => "052",
+        "BGN" => "975",
+        "BMD" => "060",
+        "BOB" => "068",
+        "BRL" => "986",
+        "BSD" => "044",
+        "BWP" => "072",
+        "BZD" => "084",
+        "CAD" => "124",
+        "CHF" => "756",
+        "CLP" => "152",
+        "CNY" => "156",
+        "COP" => "170",
+        "CRC" => "188",
+        "CZK" => "203",
+        "DKK" => "208",
+        "DOP" => "214",
+        "EGP" => "818",
+        "EUR" => "978",
+        "GBP" => "826",
+        "GEL" => "981",
+        "GIP" => "292",
+        "GTQ" => "320",
+        "GYD" => "328",
+        "HKD" => "344",
+        "HNL" => "340",
+        "HRK" => "191",
+        "HUF" => "348",
+        "ISK" => "352",
+        "IDR" => "360",
+        "ILS" => "376",
+        "INR" => "356",
+        "JPY" => "392",
+        "JMD" => "388",
+        "KES" => "404",
+        "KRW" => "410",
+        "KYD" => "136",
+        "LBP" => "422",
+        "LKR" => "144",
+        "MAD" => "504",
+        "MVR" => "462",
+        "MWK" => "454",
+        "MXN" => "484",
+        "MYR" => "458",
+        "NAD" => "516",
+        "NGN" => "566",
+        "NIO" => "558",
+        "NOK" => "578",
+        "NPR" => "524",
+        "NZD" => "554",
+        "PAB" => "590",
+        "PEN" => "604",
+        "PGK" => "598",
+        "PHP" => "608",
+        "PKR" => "586",
+        "PLN" => "985",
+        "PYG" => "600",
+        "QAR" => "634",
+        "RON" => "946",
+        "RSD" => "941",
+        "RUB" => "643",
+        "RWF" => "646",
+        "SAR" => "682",
+        "SEK" => "752",
+        "SGD" => "702",
+        "SRD" => "968",
+        "THB" => "764",
+        "TND" => "788",
+        "TRY" => "949",
+        "TTD" => "780",
+        "TWD" => "901",
+        "TZS" => "834",
+        "UAH" => "980",
+        "UGX" => "800",
+        "USD" => "840",
+        "UYU" => "858",
+        "VND" => "704",
+        "WST" => "882",
+        "XAF" => "950",
+        "XCD" => "951",
+        "XOF" => "952",
+        "ZAR" => "710"
       }
 
       CVV_CODE = {
@@ -86,140 +139,238 @@ module ActiveMerchant #:nodoc:
       }
 
       def initialize(options = {})
-        requires!(options, :login, :password)
+        requires!(options, :login, :shared_secret)
+        @threeds_required = false
+        if (options[:threeDSRequired])
+          ActiveMerchant.deprecated(THREEDSECURE_REQUIRED_DEPRECATION_MESSAGE)
+          @threeds_required = options[:threeDSRequired]
+        end
         super
       end
 
-      def purchase(money, credit_card, options = {})
-        requires!(options, :order_id)
-
+      def authorize(money, credit_card_or_reference, options = {})
         post = {}
+        add_pair(post, :captureDelay, -1)
+        add_amount(post, money, options)
+        add_invoice(post, credit_card_or_reference, money, options)
+        add_credit_card_or_reference(post, credit_card_or_reference)
+        add_customer_data(post, options)
+        add_remote_address(post, options)
+        commit('SALE', post)
+      end
 
+      def purchase(money, credit_card_or_reference, options = {})
+        post = {}
+        add_pair(post, :captureDelay, 0)
         add_amount(post, money, options)
-        add_invoice(post, money, credit_card, options)
-        add_credit_card(post, credit_card)
-        add_address(post, options)
+        add_invoice(post, credit_card_or_reference, money, options)
+        add_credit_card_or_reference(post, credit_card_or_reference)
         add_customer_data(post, options)
+        add_remote_address(post, options)
+        commit('SALE', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_pair(post, :xref, authorization)
+        add_pair(post, :amount, amount(money), :required => true)
+        add_remote_address(post, options)
+
+        commit('CAPTURE', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        add_pair(post, :xref, authorization)
+        add_amount(post, money, options)
+        add_remote_address(post, options)
+        response = commit('REFUND_SALE', post)
+
+        return response if response.success?
+        return response unless options[:force_full_refund_if_unsettled]
+
+        if response.params["responseCode"] == "65541"
+          void(authorization, options)
+        else
+          response
+        end
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        add_pair(post, :xref, authorization)
+        add_remote_address(post, options)
+        commit('CANCEL', post)
+      end
+
+      def verify(creditcard, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, creditcard, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
 
-        commit(:purchase, post)
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((cardNumber=)\d+), '\1[FILTERED]').
+          gsub(%r((CVV=)\d+), '\1[FILTERED]')
       end
 
       private
 
       def add_amount(post, money, options)
-        add_pair(post, :Amount, amount(money), :required => true)
-        add_pair(post, :CurrencyCode, currency_code(options[:currency] || currency(money)), :required => true)
+        add_pair(post, :amount, amount(money), :required => true)
+        add_pair(post, :currencyCode, currency_code(options[:currency] || currency(money)))
       end
 
       def add_customer_data(post, options)
-        add_pair(post, :BillingEmail, options[:email])
-        add_pair(post, :BillingPhoneNumber, options[:phone])
+        add_pair(post, :customerEmail, options[:email])
+        if (address = options[:billing_address] || options[:address])
+          add_pair(post, :customerAddress, "#{address[:address1]} #{address[:address2]}".strip)
+          add_pair(post, :customerPostCode, address[:zip])
+          add_pair(post, :customerPhone, options[:phone])
+          add_pair(post, :customerCountryCode, address[:country] || 'GB')
+        else
+          add_pair(post, :customerCountryCode, 'GB')
+        end
       end
 
-      def add_address(post, options)
-        address = options[:billing_address] || options[:address]
-
-        return if address.nil?
+      def add_invoice(post, credit_card_or_reference, money, options)
+        add_pair(post, :transactionUnique, options[:order_id], :required => true)
+        add_pair(post, :orderRef, options[:description] || options[:order_id], :required => true)
+        add_pair(post, :statementNarrative1, options[:merchant_name]) if options[:merchant_name]
+        add_pair(post, :statementNarrative2, options[:dynamic_descriptor]) if options[:dynamic_descriptor]
+        if credit_card_or_reference.respond_to?(:number)
+          if ['american_express', 'diners_club'].include?(card_brand(credit_card_or_reference).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
 
-        add_pair(post, :BillingStreet, address[:address1])
-        add_pair(post, :BillingHouseNumber, address[:address2])
-        add_pair(post, :BillingCity, address[:city])
-        add_pair(post, :BillingState, address[:state])
-        add_pair(post, :BillingPostCode, address[:zip])
+        add_pair(post, :type, options[:type] || '1')
+        add_threeds_required(post, options)
       end
 
-      def add_invoice(post, money, credit_card, options)
-        add_pair(post, :TransactionUnique, options[:order_id], :required => true)
-        add_pair(post, :OrderDesc, options[:description] || options[:order_id], :required => true)
-
-        if [ 'american_express', 'diners_club' ].include?(card_brand(credit_card).to_s)
-          add_pair(post, :AEIT1Quantity,  1)
-          add_pair(post, :AEIT1Description,  (options[:description] || options[:order_id]).slice(0, 15))
-          add_pair(post, :AEIT1GrossValue, amount(money))
+      def add_credit_card_or_reference(post, credit_card_or_reference)
+        if credit_card_or_reference.respond_to?(:number)
+          add_credit_card(post, credit_card_or_reference)
+        else
+          add_reference(post, credit_card_or_reference.to_s)
         end
       end
 
+      def add_reference(post, reference)
+        add_pair(post, :xref, reference, :required => true)
+      end
+
       def add_credit_card(post, credit_card)
-        add_pair(post, :CardName, credit_card.name, :required => true)
-        add_pair(post, :CardNumber, credit_card.number, :required => true)
+        add_pair(post, :customerName, credit_card.name, :required => true)
+        add_pair(post, :cardNumber, credit_card.number, :required => true)
 
-        add_pair(post, :ExpiryDateMM, format(credit_card.month, :two_digits), :required => true)
-        add_pair(post, :ExpiryDateYY, format(credit_card.year, :two_digits), :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, :StartDateMM, format(credit_card.start_month, :two_digits))
-          add_pair(post, :StartDateYY, format(credit_card.start_year, :two_digits))
+          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, :IssueNumber, credit_card.issue_number)
+          add_pair(post, :cardIssueNumber, credit_card.issue_number)
         end
 
-        add_pair(post, :CV2, credit_card.verification_value)
+        add_pair(post, :cardCVV, credit_card.verification_value)
       end
 
-      def commit(action, parameters)
-        response = parse( ssl_post(self.live_url, post_data(action, parameters)) )
-
-        Response.new(response[:response_code] == APPROVED, message_from(response), response,
-          :test => test?,
-          :authorization => response[:cross_reference],
-          :cvv_result => CVV_CODE[ response[:avscv2_response_code].to_s[0, 1] ],
-          :avs_result => {
-            :street_match => AVS_STREET_MATCH[ response[:avscv2_response_code].to_s[2, 1] ],
-            :postal_match => AVS_POSTAL_MATCH[ response[:avscv2_response_code].to_s[1, 1] ]
-          }
-        )
+      def add_threeds_required(post, options)
+        add_pair(post, :threeDSRequired, (options[:threeds_required] || @threeds_required) ? 'Y' : 'N')
       end
 
-      def message_from(results)
-        results[:response_code] == APPROVED ? "APPROVED" : results[:message]
+      def add_remote_address(post, options={})
+        add_pair(post, :remoteAddress, options[:ip] || '1.1.1.1')
       end
 
-      def post_data(action, parameters = {})
-        parameters.update(
-          :MerchantPassword => @options[:password],
-          :MerchantID => @options[:login],
-          :MessageType => TRANSACTIONS[action],
-          :CallBack => "disable",
-          :DuplicateDelay => "0",
-          :EchoCardType => "YES",
-          :EchoAmount => "YES",
-          :EchoAVSCV2ResponseCode => "YES",
-          :ReturnAVSCV2Message => "YES",
-          :CountryCode => '826' # 826 for UK based merchant
-        )
+      def normalize_line_endings(str)
+        str.gsub(/%0D%0A|%0A%0D|%0D/, "%0A")
+      end
 
-        add_pair(parameters, :Dispatch, action == :authorization ? "LATER" : "NOW")
+      def add_hmac(post)
+        result = post.sort.collect { |key, value| "#{key}=#{normalize_line_endings(CGI.escape(value.to_s))}" }.join("&")
+        result = Digest::SHA512.hexdigest("#{result}#{@options[:shared_secret]}")
 
-        parameters.collect { |key, value| "VP#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        add_pair(post, :signature, result)
       end
 
-      # VPCrossReference
-      # The value in VPCrossReference on a success transaction will contain
-      # a unique reference that you may use to run future transactions.
-      # Please note that cross reference transactions must come a static IP
-      # addressed that has been pre-registered with Cardstream. To
-      # register an IP address please send it to support@cardstream.com
-      # with your Cardstream issued merchant ID and it will be added to
-      # your account.
       def parse(body)
         result = {}
         pairs = body.split("&")
         pairs.each do |pair|
           a = pair.split("=")
-          result[a[0].gsub(/^VP/,'').underscore.to_sym] = a[1]
+          # because some value pairs don't have a value
+          result[a[0].to_sym] = a[1] == nil ? '' : CGI.unescape(a[1])
         end
-
         result
       end
 
+      def commit(action, parameters)
+        parameters.update(:countryCode => self.supported_countries[0]) unless ['CAPTURE', 'CANCEL'].include?(action)
+        parameters.update(
+          :merchantID => @options[:login],
+          :action => action
+        )
+        # adds a signature to the post hash/array
+        add_hmac(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],
+                     :cvv_result => CVV_CODE[response[:avscv2ResponseCode].to_s[0, 1]],
+                     :avs_result => avs_from(response)
+        )
+      end
+
+      def avs_from(response)
+        postal_match = AVS_POSTAL_MATCH[response[:avscv2ResponseCode].to_s[1, 1]]
+        street_match = AVS_STREET_MATCH[response[:avscv2ResponseCode].to_s[2, 1]]
+
+        code = if postal_match == "Y" && street_match == "Y"
+          "M"
+        elsif postal_match == "Y"
+          "P"
+        elsif street_match == "Y"
+          "A"
+        else
+          "I"
+        end
+
+        AVSResult.new({
+          :code => code,
+          :postal_match => postal_match,
+          :street_match => street_match
+        })
+      end
+
+
       def currency_code(currency)
         CURRENCY_CODES[currency]
       end
 
+      def post_data(action, parameters = {})
+        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
-