activemerchant 1.58.0 → 1.59.0

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

@@ -572,12 +572,15 @@ module ActiveMerchant #:nodoc:
         end
         parameters[:billing] = map_address(options[:billing_address]) if options[:billing_address]
         parameters[:shipping] = map_address(options[:shipping_address]) if options[:shipping_address]
-        parameters[:channel] = application_id if application_id.present? && application_id != "ActiveMerchant"
 
-        if options[:descriptor_name] || options[:descriptor_phone]
+        channel = @options[:channel] || application_id
+        parameters[:channel] = channel if channel
+
+        if options[:descriptor_name] || options[:descriptor_phone] || options[:descriptor_url]
           parameters[:descriptor] = {
             name: options[:descriptor_name],
-            phone: options[:descriptor_phone]
+            phone: options[:descriptor_phone],
+            url: options[:descriptor_url]
           }
         end
 

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

@@ -75,21 +75,21 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      def authorize(money, creditcard, options = {})
+      def authorize(money, credit_card_or_reference, options = {})
         post = {}
         add_pair(post, :captureDelay, -1)
         add_amount(post, money, options)
-        add_invoice(post, creditcard, money, options)
-        add_creditcard(post, creditcard)
+        add_invoice(post, credit_card_or_reference, money, options)
+        add_credit_card_or_reference(post, credit_card_or_reference)
         add_customer_data(post, options)
         commit('SALE', post)
       end
 
-      def purchase(money, creditcard, options = {})
+      def purchase(money, credit_card_or_reference, options = {})
         post = {}
         add_amount(post, money, options)
-        add_invoice(post, creditcard, money, options)
-        add_creditcard(post, creditcard)
+        add_invoice(post, credit_card_or_reference, money, options)
+        add_credit_card_or_reference(post, credit_card_or_reference)
         add_customer_data(post, options)
         commit('SALE', post)
       end
@@ -112,7 +112,7 @@ module ActiveMerchant #:nodoc:
       def void(authorization, options = {})
         post = {}
         add_pair(post, :xref, authorization)
-        commit('REFUND', post)
+        commit('CANCEL', post)
       end
 
       def verify(creditcard, options={})
@@ -149,20 +149,34 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_invoice(post, credit_card, money, options)
+      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)
-        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))
+        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, :type, options[:type] || '1')
         add_threeds_required(post, options)
       end
 
-      def add_creditcard(post, credit_card)
+      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, :customerName, credit_card.name, :required => true)
         add_pair(post, :cardNumber, credit_card.number, :required => true)
 
@@ -183,8 +197,12 @@ module ActiveMerchant #:nodoc:
         add_pair(post, :threeDSRequired, (options[:threeds_required] || @threeds_required) ? 'Y' : 'N')
       end
 
+      def normalize_line_endings(str)
+        str.gsub(/%0D%0A|%0A%0D|%0D/, "%0A")
+      end
+
       def add_hmac(post)
-        result = post.sort.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        result = post.sort.collect { |key, value| "#{key}=#{normalize_line_endings(CGI.escape(value.to_s))}" }.join("&")
         result = Digest::SHA512.hexdigest("#{result}#{@options[:shared_secret]}")
 
         add_pair(post, :signature, result)
@@ -202,7 +220,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, parameters)
-        parameters.update(:countryCode => self.supported_countries[0]) unless action == 'CAPTURE'
+        parameters.update(:countryCode => self.supported_countries[0]) unless ['CAPTURE', 'CANCEL'].include?(action)
         parameters.update(
           :merchantID => @options[:login],
           :action => action

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

@@ -10,6 +10,7 @@ module ActiveMerchant #:nodoc:
       self.homepage_url        = "http://www.higherone.com/"
       self.display_name        = "Cashnet"
       self.money_format        = :dollars
+      self.max_retries         = 0
 
       # Creates a new CashnetGateway
       #

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

@@ -30,8 +30,8 @@ module ActiveMerchant #:nodoc:
     # * The order of the XML elements does matter, make sure to follow the order in
     #   the documentation exactly.
     class CyberSourceGateway < Gateway
-      self.test_url = 'https://ics2wstest.ic3.com/commerce/1.x/transactionProcessor'
-      self.live_url = 'https://ics2ws.ic3.com/commerce/1.x/transactionProcessor'
+      self.test_url = 'https://ics2wstesta.ic3.com/commerce/1.x/transactionProcessor'
+      self.live_url = 'https://ics2wsa.ic3.com/commerce/1.x/transactionProcessor'
 
       XSD_VERSION = "1.121"
 
@@ -683,7 +683,11 @@ module ActiveMerchant #:nodoc:
       # Contact CyberSource, make the SOAP request, and parse the reply into a
       # Response object
       def commit(request, options)
-        response = parse(ssl_post(test? ? self.test_url : self.live_url, build_request(request, options)))
+        begin
+          response = parse(ssl_post(test? ? self.test_url : self.live_url, build_request(request, options)))
+        rescue ResponseError => e
+          response = parse(e.response.body)
+        end
 
         success = response[:decision] == "ACCEPT"
         message = @@response_codes[('r' + response[:reasonCode]).to_sym] rescue response[:message]

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

@@ -0,0 +1,293 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class GlobalCollectGateway < Gateway
+      self.display_name = "GlobalCollect"
+      self.homepage_url = "http://www.globalcollect.com/"
+
+      self.test_url = "https://api-sandbox.globalcollect.com/"
+      self.live_url = "https://api.globalcollect.com/"
+
+      self.supported_countries = %w(AD AE AT AU BD BE BG BN CA CH CY CZ DE DK
+      EE EG ES FI FR GB GI GR HK HU ID IE IL IM IN IS IT JO KW LB LI LK LT LU
+      LV MC MT MU MV MX MY NL NO NZ OM PH PL PT QA RO SA SE SG SI SK SM TR TT
+      UM US VA VN ZA)
+      self.default_currency = "USD"
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      def initialize(options={})
+        requires!(options, :merchant_id, :api_key_id, :secret_api_key)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        MultiResponse.run do |r|
+          r.process { authorize(money, payment, options) }
+          r.process { capture(money, r.authorization, options) }
+        end
+      end
+
+      def authorize(money, payment, options={})
+        post = nestable_hash
+        add_order(post, money, options)
+        add_payment(post, payment)
+        add_customer_data(post, options, payment)
+        add_address(post, payment, options)
+
+        commit(:authorize, post)
+      end
+
+      def capture(money, authorization, options={})
+        post = nestable_hash
+        add_order(post, money, options)
+        add_customer_data(post, options)
+        commit(:capture, post, authorization)
+      end
+
+      def refund(money, authorization, options={})
+        post = nestable_hash
+        add_amount(post, money, options={})
+        add_refund_customer_data(post, options)
+        commit(:refund, post, authorization)
+      end
+
+      def void(authorization, options={})
+        post = nestable_hash
+        commit(:void, post, authorization)
+      end
+
+      def verify(payment, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, payment, options) }
+          r.process { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: )[^\\]*)i, '\1[FILTERED]').
+          gsub(%r(("cardNumber\\":\\")\d+), '\1[FILTERED]').
+          gsub(%r(("cvv\\":\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      BRAND_MAP = {
+        "visa" => "1",
+        "american_express" => "2",
+        "master" => "3",
+        "discover" => "128"
+      }
+
+      def add_order(post, money, options)
+        post["order"]["amountOfMoney"] = {
+          "amount" => amount(money),
+          "currencyCode" => options[:currency] || currency(money)
+        }
+        post["order"]["references"] = {
+          "merchantReference" => options[:order_id],
+          "descriptor" => options[:description] # Max 256 chars
+        }
+        post["order"]["references"]["invoiceData"] = {
+          "invoiceNumber" => options[:invoice]
+        }
+      end
+
+      def add_amount(post, money, options)
+        post["amountOfMoney"] = {
+          "amount" => amount(money),
+          "currencyCode" => options[:currency] || currency(money)
+        }
+      end
+
+      def add_payment(post, payment)
+        year  = format(payment.year, :two_digits)
+        month = format(payment.month, :two_digits)
+        expirydate =   "#{month}#{year}"
+
+        post["cardPaymentMethodSpecificInput"] = {
+            "paymentProductId" => BRAND_MAP[payment.brand],
+            "skipAuthentication" => "true", # refers to 3DSecure
+            "skipFraudService" => "true"
+        }
+        post["cardPaymentMethodSpecificInput"]["card"] = {
+            "cvv" => payment.verification_value,
+            "cardNumber" => payment.number,
+            "expiryDate" => expirydate,
+            "cardholderName" => payment.name
+        }
+      end
+
+      def add_customer_data(post, options, payment = nil)
+        post["order"]["customer"] = {
+          "merchantCustomerId" => options[:customer]
+        }
+        if payment
+          post["order"]["customer"]["personalInformation"] = {
+            "name" => {
+              "firstName" => payment.first_name,
+              "surname" => payment.last_name
+            }
+          }
+        end
+        post["order"]["companyInformation"] = {
+          "name" => options[:company]
+        }
+        post["order"]["contactDetails"] = {
+          "emailAddress" => options[:email]
+        }
+        if address = options[:billing_address] || options[:address]
+          post["order"]["contactDetails"] = {
+            "phoneNumber" => address[:phone]
+          }
+        end
+      end
+
+      def add_refund_customer_data(post, options)
+        if address = options[:billing_address] || options[:address]
+          post["customer"]["address"] = {
+            "countryCode" => address[:country]
+          }
+          post["customer"]["contactDetails"] = {
+            "emailAddress" => options[:email],
+            "phoneNumber" => address[:phone]
+          }
+        end
+      end
+
+      def add_address(post, creditcard, options)
+        billing_address = options[:billing_address] || options[:address]
+        shipping_address = options[:shipping_address]
+        if billing_address = options[:billing_address] || options[:address]
+          post["order"]["customer"]["billingAddress"] = {
+            "street" => billing_address[:address1],
+            "additionalInfo" => billing_address[:address2],
+            "zip" => billing_address[:zip],
+            "city" => billing_address[:city],
+            "state" => billing_address[:state],
+            "countryCode" => billing_address[:country]
+          }
+        end
+        if shipping_address
+          post["order"]["customer"]["shippingAddress"] = {
+            "street" => shipping_address[:address1],
+            "additionalInfo" => shipping_address[:address2],
+            "zip" => shipping_address[:zip],
+            "city" => shipping_address[:city],
+            "state" => shipping_address[:state],
+            "countryCode" => shipping_address[:country]
+          }
+          post["order"]["customer"]["shippingAddress"]["name"] = {
+            "firstName" => shipping_address[:firstname],
+            "surname" => shipping_address[:lastname]
+          }
+        end
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def url(action, authorization)
+        (test? ? test_url : live_url) + uri(action, authorization)
+      end
+
+      def uri(action, authorization)
+        uri = "/v1/#{@options[:merchant_id]}/"
+        case action
+        when :authorize
+          uri + "payments"
+        when :capture
+          uri + "payments/#{authorization}/approve"
+        when :refund
+          uri + "payments/#{authorization}/refund"
+        when :void
+          uri + "payments/#{authorization}/cancel"
+        end
+      end
+
+      def commit(action, post, authorization = nil)
+        begin
+          response = parse(ssl_post(url(action, authorization), post.to_json, headers(action, post, authorization)))
+        rescue ResponseError => e
+          if e.response.code.to_i >= 400
+            response = parse(e.response.body)
+          end
+        end
+
+        succeeded = success_from(response)
+        Response.new(
+        succeeded,
+        message_from(succeeded, response),
+        response,
+        authorization: authorization_from(succeeded, response),
+        error_code: error_code_from(succeeded, response),
+        test: test?
+        )
+
+      end
+
+      def headers(action, post, authorization = nil)
+        {
+          "Content-type"  => content_type,
+          "Authorization" => auth_digest(action, post, authorization),
+          "Date" => date
+        }
+      end
+
+      def auth_digest(action, post, authorization = nil)
+        data = <<-EOS
+POST
+#{content_type}
+#{date}
+#{uri(action, authorization)}
+EOS
+        digest = OpenSSL::Digest.new('sha256')
+        key = @options[:secret_api_key]
+        "GCS v1HMAC:#{@options[:api_key_id]}:#{Base64.strict_encode64(OpenSSL::HMAC.digest(digest, key, data))}"
+      end
+
+      def date
+        @date ||= Time.now.strftime("%a, %d %b %Y %H:%M:%S %Z") # Must be same in digest and HTTP header
+      end
+
+      def content_type
+        "application/json"
+      end
+
+      def success_from(response)
+        !response["errorId"]
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          response["errors"][0]["message"] || "Unable to read error message"
+        end
+      end
+
+      def authorization_from(succeeded, response)
+        if succeeded
+          response["id"] || response["payment"]["id"] || response["paymentResult"]["payment"]["id"]
+        else
+          response["errorId"]
+        end
+      end
+
+      def error_code_from(succeeded, response)
+        unless succeeded
+          response["errors"][0]["code"] || "Unable to read error code"
+        end
+      end
+
+      def nestable_hash
+        Hash.new {|h,k| h[k] = Hash.new(&h.default_proc) }
+      end
+    end
+  end
+end

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

@@ -20,7 +20,7 @@ module ActiveMerchant #:nodoc:
       self.money_format = :cents
 
       ACTION_CODE_MESSAGES = {
-        "000" =>  "Approved.",        
+        "000" =>  "Approved.",
         "001" =>  "Refer to card issuer.",
         "002" =>  "Refer to card issuer, special condition.",
         "003" =>  "Invalid merchant or service provider.",
@@ -167,7 +167,7 @@ module ActiveMerchant #:nodoc:
 
       def void(reference, options = {})
         transaction_id, approval, amount, token = reference.split(";")
-        commit(amount.to_i, build_void_request(amount.to_i, transaction_id, approval, token))
+        commit(amount.to_i, build_void_request(amount.to_i, transaction_id, approval, token, options))
       end
 
       def credit(money, transaction_id_or_card, options = {})
@@ -200,13 +200,16 @@ module ActiveMerchant #:nodoc:
 
       private
 
-      def build_xml_request(transaction_type, transaction_id = nil, &block)
+      def build_xml_request(transaction_type, options = {}, transaction_id = nil, &block)
         xml = Builder::XmlMarkup.new
         xml.tag! 'JetPay' do
           # The basic values needed for any request
           xml.tag! 'TerminalID', @options[:login]
           xml.tag! 'TransactionType', transaction_type
           xml.tag! 'TransactionID', transaction_id.nil? ? generate_unique_id.slice(0, 18) : transaction_id
+          if options && options[:origin]
+            xml.tag! 'Origin', options[:origin]
+          end
 
           if block_given?
             yield xml
@@ -217,7 +220,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def build_sale_request(money, credit_card, options)
-        build_xml_request('SALE') do |xml|
+        build_xml_request('SALE', options) do |xml|
           add_credit_card(xml, credit_card)
           add_addresses(xml, options)
           add_customer_data(xml, options)
@@ -243,14 +246,14 @@ module ActiveMerchant #:nodoc:
       end
 
       def build_capture_request(transaction_id, money, options)
-        build_xml_request('CAPT', transaction_id) do |xml|
+        build_xml_request('CAPT', options, transaction_id) do |xml|
           xml.tag! 'TotalAmount', amount(money)
           add_user_defined_fields(xml, options)
         end
       end
 
-      def build_void_request(money, transaction_id, approval, token)
-        build_xml_request('VOID', transaction_id) do |xml|
+      def build_void_request(money, transaction_id, approval, token, options)
+        build_xml_request('VOID', options, transaction_id) do |xml|
           xml.tag! 'Approval', approval
           xml.tag! 'TotalAmount', amount(money)
           xml.tag! 'Token', token if token
@@ -260,7 +263,7 @@ module ActiveMerchant #:nodoc:
 
       # `transaction_id` may be nil for unlinked credit transactions.
       def build_credit_request(transaction_type, money, transaction_id, card, token, options)
-        build_xml_request(transaction_type, transaction_id) do |xml|
+        build_xml_request(transaction_type, options, transaction_id) do |xml|
           add_credit_card(xml, card) if card
           add_invoice_data(xml, options)
           add_addresses(xml, options)