activemerchant 1.49.0 → 1.50.0

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

@@ -54,16 +54,19 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, money, fields)
         fields[:amount] = amount(money)
-        url = live_url + @options[:merchant_gateway_name]
-        response = parse(ssl_post(url, post_data(action, fields)))
+        url = live_url + CGI.escape(@options[:merchant_gateway_name])
+        raw_response = ssl_post(url, post_data(action, fields))
+        parsed_response = parse(raw_response)
 
-        success = (response[:result] == '0')
+        return unparsable_response(raw_response) unless parsed_response
+
+        success = (parsed_response[:result] == '0')
         Response.new(
           success,
-          CASHNET_CODES[response[:result]],
-          response,
+          CASHNET_CODES[parsed_response[:result]],
+          parsed_response,
           test:          test?,
-          authorization: (success ? response[:tx] : '')
+          authorization: (success ? parsed_response[:tx] : '')
         )
       end
 
@@ -113,8 +116,10 @@ module ActiveMerchant #:nodoc:
       end
 
       def parse(body)
-        response_data = body.match(/<cngateway>(.*)<\/cngateway>/)[1]
-        Hash[CGI::parse(response_data).map{|k,v| [k.to_sym,v.first]}]
+        match = body.match(/<cngateway>(.*)<\/cngateway>/)
+        return nil unless match
+
+        Hash[CGI::parse(match[1]).map{|k,v| [k.to_sym,v.first]}]
       end
 
       def handle_response(response)
@@ -126,6 +131,12 @@ module ActiveMerchant #:nodoc:
         raise ResponseError.new(response)
       end
 
+      def unparsable_response(raw_response)
+        message = "Unparsable response received from Cashnet. Please contact Cashnet if you continue to receive this message."
+        message += " (The raw response returned by the API was #{raw_response.inspect})"
+        return Response.new(false, message)
+      end
+
       CASHNET_CODES = {
         '0' => 'Success',
         '1' => 'Invalid customer code, no customer code specified',

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

@@ -49,6 +49,8 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_void_required_elements(post)
         add_reference(post, authorization)
+        add_tax(post, options)
+
         commit("Void", post)
       end
 
@@ -89,33 +91,13 @@ module ActiveMerchant #:nodoc:
 
       private
 
-      CURRENCY_CODES = Hash.new{|h,k| raise ArgumentError.new("Unsupported currency: #{k}")}
-      CURRENCY_CODES["AUD"] = "036"
-      CURRENCY_CODES["CAD"] = "124"
-      CURRENCY_CODES["CHF"] = "756"
-      CURRENCY_CODES["CZK"] = "203"
-      CURRENCY_CODES["DKK"] = "208"
-      CURRENCY_CODES["EUR"] = "978"
-      CURRENCY_CODES["GBP"] = "826"
-      CURRENCY_CODES["HKD"] = "344"
-      CURRENCY_CODES["HUF"] = "348"
-      CURRENCY_CODES["IRR"] = "364"
-      CURRENCY_CODES["JPY"] = "392"
-      CURRENCY_CODES["LVL"] = "428"
-      CURRENCY_CODES["MYR"] = "458"
-      CURRENCY_CODES["NOK"] = "578"
-      CURRENCY_CODES["PLN"] = "985"
-      CURRENCY_CODES["SEK"] = "752"
-      CURRENCY_CODES["SGD"] = "702"
-      CURRENCY_CODES["USD"] = "840"
-      CURRENCY_CODES["ZAR"] = "710"
-
       def add_invoice(post, money, options)
         post[:Amount] = amount(money)
-        post[:CurrencyCode] = CURRENCY_CODES[options[:currency] || currency(money)]
-        post[:TaxAmount] = amount(options[:tax])
+        post[:CurrencyCode] = options[:currency] || currency(money)
         post[:InvoiceNumber] = options[:order_id]
-        post[:InvoiceDetail] = options[:description]
+        post[:InvoiceDetail] = options[:invoice_detail] if options[:invoice_detail]
+        post[:CustomerCode] = options[:customer_code] if options[:customer_code]
+        add_tax(post, options)
       end
 
       def add_payment_method(post, payment_method)
@@ -124,7 +106,7 @@ module ActiveMerchant #:nodoc:
         post[:CardVerificationNumber] = payment_method.verification_value
         post[:CardExpirationDate] = format(payment_method.month, :two_digits) + format(payment_method.year, :two_digits)
         post[:CardLastFourDigits] = payment_method.last_digits
-        post[:MagneticData] = payment_method.track_data
+        post[:MagneticData] = payment_method.track_data if payment_method.track_data
       end
 
       def add_customer_data(post, options)
@@ -143,6 +125,10 @@ module ActiveMerchant #:nodoc:
         post[:IMEI] = nil
       end
 
+      def add_tax(post, options)
+        post[:TaxAmount] = amount(options[:tax] || 0)
+      end
+
       def add_reference(post, authorization)
         reference_number, last_four_digits, original_amount = split_authorization(authorization)
         post[:ReferenceNumber] = reference_number
@@ -184,7 +170,7 @@ module ActiveMerchant #:nodoc:
         {
           "Accept-Encoding" => "gzip,deflate",
           "Content-Type"  => "text/xml;charset=UTF-8",
-          "SOAPAction"  => "http://tempuri.org/Transactional/ProcessCard"
+          "SOAPAction"  => "http://tempuri.org/Transactional/ProcessCreditCard"
         }
       end
 
@@ -204,11 +190,11 @@ module ActiveMerchant #:nodoc:
 <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tem="http://tempuri.org/" xmlns:acr="http://schemas.datacontract.org/2004/07/Acriter.ABI.CenPOS.EPayment.VirtualTerminal.Common" xmlns:acr1="http://schemas.datacontract.org/2004/07/Acriter.ABI.CenPOS.EPayment.VirtualTerminal.v6.Common" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
 <soapenv:Header/>
    <soapenv:Body>
-      <tem:ProcessCard>
+      <tem:ProcessCreditCard>
          <tem:request>
            #{body}
          </tem:request>
-      </tem:ProcessCard>
+      </tem:ProcessCreditCard>
    </soapenv:Body>
 </soapenv:Envelope>
         EOS
@@ -219,7 +205,7 @@ module ActiveMerchant #:nodoc:
 
         doc = Nokogiri::XML(xml)
         doc.remove_namespaces!
-        body = doc.xpath("//ProcessCardResult")
+        body = doc.xpath("//ProcessCreditCardResult")
         body.children.each do |node|
           if (node.elements.size == 0)
             response[node.name.underscore.to_sym] = node.text

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

@@ -69,7 +69,7 @@ module ActiveMerchant #:nodoc:
         details[:name] = options[:customer] if options[:customer]
         details[:email] = options[:email] if options[:email]
         details[:phone] = options[:phone] if options[:phone]
-        details[:device_fingerprint] = options[:device_fingerprint] if options[:device_fingerprint]
+        post[:device_fingerprint] = options[:device_fingerprint] if options[:device_fingerprint]
         details[:ip] = options[:ip] if options[:ip]
         add_billing_address(details, options)
         add_line_items(details, options)
@@ -160,6 +160,7 @@ module ActiveMerchant #:nodoc:
       def headers(meta)
         {
           "Accept" => "application/vnd.conekta-v#{options[:version]}+json",
+          "Accept-Language" => "es",
           "Authorization" => "Basic " + Base64.encode64("#{options[:key]}:"),
           "RaiseHtmlError" => "false",
           "Conekta-Client-User-Agent" => {"agent"=>"Conekta ActiveMerchantBindings/#{ActiveMerchant::VERSION}"}.to_json,
@@ -181,7 +182,7 @@ module ActiveMerchant #:nodoc:
 
         Response.new(
           success,
-          raw_response["message"],
+          raw_response["message_to_purchaser"],
           raw_response,
           test: test?,
           authorization: raw_response["id"]

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

@@ -0,0 +1,206 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class DibsGateway < Gateway
+      self.display_name = "DIBS"
+      self.homepage_url = "http://www.dibspayment.com/"
+
+      self.live_url = "https://api.dibspayment.com/merchant/v1/JSON/Transaction/"
+
+      self.supported_countries = ["US", "FI", "NO", "SE", "GB"]
+      self.default_currency = "USD"
+      self.money_format = :cents
+      self.ssl_version = :TLSv1
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      def initialize(options={})
+        requires!(options, :merchant_id, :secret_key)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        MultiResponse.run(false) 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 = {}
+        add_amount(post, amount)
+        add_invoice(post, amount, options)
+        if (payment_method.respond_to?(:number))
+          add_payment_method(post, payment_method, options)
+          commit(:authorize, post)
+        else
+          add_ticket_id(post, payment_method)
+          commit(:authorize_ticket, post)
+        end
+
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_amount(post, amount)
+        add_reference(post, authorization)
+
+        commit(:capture, post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+
+        commit(:void, post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_amount(post, amount)
+        add_reference(post, authorization)
+
+        commit(:refund, 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
+
+      def store(payment_method, options = {})
+        post = {}
+
+        add_invoice(post, 0, options)
+        add_payment_method(post, payment_method, options)
+
+        commit(:store, post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r(("cardNumber\\?":\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("cvc\\?":\\?")[^"]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      CURRENCY_CODES = Hash.new{|h,k| raise ArgumentError.new("Unsupported currency: #{k}")}
+      CURRENCY_CODES["USD"] = "840"
+      CURRENCY_CODES["DKK"] = "208"
+      CURRENCY_CODES["NOK"] = "578"
+      CURRENCY_CODES["SEK"] = "752"
+      CURRENCY_CODES["GBP"] = "826"
+      CURRENCY_CODES["EUR"] = "978"
+
+      def add_invoice(post, money, options)
+        post[:orderId] = options[:order_id] || generate_unique_id
+        post[:currency] = CURRENCY_CODES[options[:currency] || currency(money)]
+      end
+
+      def add_ticket_id(post, payment_method)
+        post[:ticketId] = payment_method
+      end
+
+      def add_payment_method(post, payment_method, options)
+        post[:cardNumber] = payment_method.number
+        post[:cvc] = payment_method.verification_value
+        post[:expYear] = format(payment_method.year, :two_digits)
+        post[:expMonth] = payment_method.month
+
+        post[:startMonth] = payment_method.start_month if payment_method.start_month
+        post[:startYear] = payment_method.start_year if payment_method.start_year
+        post[:issueNumber] = payment_method.issue_number if payment_method.issue_number
+        post[:clientIp] = options[:ip] || "127.0.0.1"
+        post[:test] = true if test?
+      end
+
+
+      def add_reference(post, authorization)
+        post[:transactionId] = authorization
+      end
+
+      def add_amount(post, amount)
+        post[:amount] = amount
+      end
+
+      ACTIONS = {
+        authorize: "AuthorizeCard",
+        authorize_ticket: "AuthorizeTicket",
+        capture: "CaptureTransaction",
+        void: "CancelTransaction",
+        refund: "RefundTransaction",
+        store: "CreateTicket"
+      }
+
+      def commit(action, post)
+        post[:merchantId] = @options[:merchant_id]
+
+        data = build_request(post)
+        raw = parse(ssl_post(url(action), "request=#{data}", headers))
+        succeeded = success_from(raw)
+        Response.new(
+          succeeded,
+          message_from(succeeded, raw),
+          raw,
+          authorization: authorization_from(post, raw),
+          test: test?
+        )
+      rescue JSON::ParserError
+        unparsable_response(raw)
+      end
+
+      def headers
+        {
+          "Content-Type" => "application/x-www-form-urlencoded"
+        }
+      end
+
+      def build_request(post)
+        add_hmac(post)
+        post.to_json
+      end
+
+      def add_hmac(post)
+        data = post.sort.collect { |key, value| "#{key}=#{value.to_s}" }.join("&")
+        digest = OpenSSL::Digest.new('sha256')
+        key = [@options[:secret_key]].pack('H*')
+        post[:MAC] = OpenSSL::HMAC.hexdigest(digest, key, data)
+      end
+
+      def url(action)
+        live_url + ACTIONS[action]
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(raw_response)
+        raw_response["status"] == "ACCEPT"
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          response["status"] + ": " + response["declineReason"] || "Unable to read error message"
+        end
+      end
+
+      def authorization_from(request, response)
+        response['transactionId'] || response['ticketId'] || request[:transactionId]
+      end
+
+      def unparsable_response(raw_response)
+        message = "Invalid JSON response received from Dibs. Please contact Dibs if you continue to receive this message."
+        message += " (The raw response returned by the API was #{raw_response.inspect})"
+        return Response.new(false, message)
+      end
+    end
+  end
+end

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

@@ -21,8 +21,6 @@ module ActiveMerchant #:nodoc:
       # Under the Your Account section
       def initialize(options = {})
         requires!(options, :username, :token)
-        @username = options[:username]
-        @token    = options[:token]
         super
       end
 
@@ -39,8 +37,8 @@ module ActiveMerchant #:nodoc:
         add_amount(post, money, options)
         add_creditcard(post, creditcard, options)
         add_extra_options(post, options)
-        post[:reference] = options[:order_id]
-        post[:customer_ip] = options[:ip]
+        add_order_id(post, options)
+        add_ip(post, options)
 
         commit(:post, 'purchases', post)
       end
@@ -51,9 +49,10 @@ module ActiveMerchant #:nodoc:
         add_amount(post, money, options)
         add_creditcard(post, creditcard, options)
         add_extra_options(post, options)
+        add_order_id(post, options)
+        add_ip(post, options)
+
         post[:capture] = false
-        post[:reference] = options[:order_id]
-        post[:customer_ip] = options[:ip]
 
         commit(:post, 'purchases', post)
       end
@@ -63,7 +62,6 @@ module ActiveMerchant #:nodoc:
         add_amount(post, money, options)
         add_extra_options(post, options)
 
-
         commit(:post, "purchases/#{CGI.escape(authorization)}/capture", post)
       end
 
@@ -72,13 +70,13 @@ module ActiveMerchant #:nodoc:
       # amount - Integer - the amount to refund
       # txn_id - String - the original transaction to be refunded
       # reference - String - your transaction reference
-      def refund(money, txn_id, reference)
+      def refund(money, txn_id, options={})
         post = {}
 
         add_extra_options(post, options)
-        post[:amount] = money
+        add_amount(post, money, options)
         post[:transaction_id] = txn_id
-        post[:reference] = reference
+        add_order_id(post, options)
 
         commit(:post, "refunds", post)
       end
@@ -86,7 +84,7 @@ module ActiveMerchant #:nodoc:
       # Tokenize a credit card
       #
       # The token is returned in the Response#authorization
-      def store(creditcard)
+      def store(creditcard, options={})
         post = {}
         add_creditcard(post, creditcard)
 
@@ -125,9 +123,18 @@ module ActiveMerchant #:nodoc:
         extra = {}
         extra[:name] = options[:merchant] if options[:merchant]
         extra[:location] = options[:merchant_location] if options[:merchant_location]
+        extra[:ecm] = "32" if options[:recurring]
         post[:extra] = extra if extra.any?
       end
 
+      def add_order_id(post, options)
+        post[:reference] = options[:order_id] || SecureRandom.hex(15)
+      end
+
+      def add_ip(post, options)
+        post[:customer_ip] = options[:ip] || "127.0.0.1"
+      end
+
       # Post the data to the gateway
       def commit(method, uri, parameters=nil)
         response = begin
@@ -197,7 +204,7 @@ module ActiveMerchant #:nodoc:
       # Builds the auth and U-A headers for the request
       def headers
         {
-          "Authorization" => "Basic " + Base64.strict_encode64(@username.to_s + ":" + @token.to_s).strip,
+          "Authorization" => "Basic " + Base64.strict_encode64(@options[:username].to_s + ":" + @options[:token].to_s).strip,
           "User-Agent" => "Fat Zebra v1.0/ActiveMerchant #{ActiveMerchant::VERSION}"
         }
       end