activemerchant 1.67.0 → 1.68.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d1e9a2bf41a0e836aba8e3d1296464f62d7765e
-  data.tar.gz: 6cd30371be55f49a0beef1eb5a3a8796cf226db0
+  metadata.gz: 3ed51178560acbebf43bedcb1e5ce966b279c04a
+  data.tar.gz: fb02cd941337c8fb5a2e2ae2626a25d967e86750
 SHA512:
-  metadata.gz: 4c0426a9d705e5b7c29031ac35ccdb1a2bf062efe8693760b485f9ece001e6149f64bbfa11dcc8cc23310ac5a13586b66683762cb0db98bd300d3eb5c8cd27d7
-  data.tar.gz: 54b90b7a5e2235c16e5ea1e91a161437b50081b2b19ccd7938f35f8398f65eafffee05eca2317c19f4cda4007986b59f9daea99db36e184b2a357a4aed437ebf
+  metadata.gz: d8fe0383adc62eb2a6af23bbe0ab0155d9121994fc7b9b0fe05f84ad7e521e3fe62db4814fb1efc02c8889e88fb561bba0807dc8133b3e39ad04d167d5b28c15
+  data.tar.gz: 2159f015c245a4ebd0dc2ba57808884f08b2923271c951c8ffd4d0b581139d1426c0cadaa6f66bb6a26de4d63a12c2dcc26cd0adafc6ac51229c04668a05b640

data/CHANGELOG

@@ -2,6 +2,25 @@
 
 == HEAD
 
+== Version 1.68.0 (June 27, 2017)
+* Authorize.Net: Return failed response if forced refund settlement fails [bizla] #2476
+* Authorize.net: Concatenate address1 and address2 [dtykocki] #2479
+* Braintree Blue: Braintree Blue: Add ECI indicator to Android Pay transactions [davidsantoso] #2474
+* Credorax: Support 0- and 3-exponent currencies [curiousepic]
+* Cybersource: update supported card types [bdewater] #2477
+* FirstData: Add a default network tokenization strategy for FirstData E4 [krystosterone] #2473
+* FirstPay: FirstPay: Update hostname and force TLSv1 minimum [davidsantoso] #2478
+* JetPay V2: Support store transactions and token based payments [shasum] #2475
+* Moneris: Add 3DS fields for decrypted Apple and Android Pay data [davidsantoso] #2457
+* Openpay: Send customer name and email in authorize and purchase [dtykocki] #2468
+* Payflow: Moved to name value pair (NVP) with payflow [jusleg] #2462
+* Payflow: Set PAYPAL_NVP header as optional [davidsantoso] #2480
+* QuickPay V10: Return last response for purchase and authorize [curiousepic] #2461
+* SafeCharge: Map billing address fields [davidsantoso] #2464
+* SafeCharge: Track currency from original transaction [davidsantoso] #2470
+* Support three-decimal currencies [curiousepic] #2466
+* Trexle: Add gateway support [hossamhossny] #2351
+
 == Version 1.67.0 (June 8, 2017)
 * Acapture: Pass 3D Secure fields [davidsantoso] #2451
 * Authorize.net: Pass Level 2 Data Fields [curiousepic] #2444
@@ -17,16 +36,6 @@
 * Payeezy: Add client_email field for telecheck [davidsantoso] #2455
 * Payeezy: Add customer_id_type and customer_id_number fields [davidsantoso] #2454
 * Quickpay V10: Fix store and token use for recurring payments [wsmoak] #2180
-
-== Version 1.66.0 (May 4, 2017)
-* Support Rails 5.1 [jhawthorn] #2407
-* ProPay: Add Canada as supported country [davidsantoso]
-* ProPay: Add gateway support [davidsantoso] #2405
-* SafeCharge: Support credit transactions [shasum] #2404
-* WePay: Add scrub method [shasum] #2406
-* iVeri: Add gateway support [curiousepic] #2400
-* iVeri: Support 3DSecure data fields [davidsantoso] #2412
-* Opp: Fix transaction success criteria and clean up options [shasum] #2414
 * Elavon: Support custom fields [curiousepic] #2416
 * WePay: Support risk headers [shasum] #2419
 * WePay: Add Canada as supported country [shasum] #2419
@@ -39,6 +48,16 @@
 * Payeezy: Default check number to 001 if not present [davidsantoso] #2439
 * Opp: Fix incorrect customParameter key to disable 3DS [davidsantoso]
 
+== Version 1.66.0 (May 4, 2017)
+* Support Rails 5.1 [jhawthorn] #2407
+* ProPay: Add Canada as supported country [davidsantoso]
+* ProPay: Add gateway support [davidsantoso] #2405
+* SafeCharge: Support credit transactions [shasum] #2404
+* WePay: Add scrub method [shasum] #2406
+* iVeri: Add gateway support [curiousepic] #2400
+* iVeri: Support 3DSecure data fields [davidsantoso] #2412
+* Opp: Fix transaction success criteria and clean up options [shasum] #2414
+
 == Version 1.65.0 (April 26, 2017)
 * Adyen: Add Adyen v18 gateway [adyenpayments] #2272
 * Authorize.Net: Force refund of unsettled payments via void [bizla] #2399

data/lib/active_merchant/billing/gateway.rb

@@ -125,8 +125,9 @@ module ActiveMerchant #:nodoc:
       class_attribute :supported_cardtypes
       self.supported_cardtypes = []
 
-      class_attribute :currencies_without_fractions
+      class_attribute :currencies_without_fractions, :currencies_with_three_decimal_places
       self.currencies_without_fractions = %w(BIF BYR CLP CVE DJF GNF HUF ISK JPY KMF KRW PYG RWF UGX VND VUV XAF XOF XPF)
+      self.currencies_with_three_decimal_places = %w()
 
       class_attribute :homepage_url
       class_attribute :display_name
@@ -263,15 +264,26 @@ module ActiveMerchant #:nodoc:
         self.currencies_without_fractions.include?(currency.to_s)
       end
 
+      def three_decimal_currency?(currency)
+        self.currencies_with_three_decimal_places.include?(currency.to_s)
+      end
+
       def localized_amount(money, currency)
         amount = amount(money)
 
-        return amount unless non_fractional_currency?(currency)
-
-        if self.money_format == :cents
-          sprintf("%.0f", amount.to_f / 100)
-        else
-          amount.split('.').first
+        return amount unless non_fractional_currency?(currency) || three_decimal_currency?(currency)
+        if non_fractional_currency?(currency)
+          if self.money_format == :cents
+            sprintf("%.0f", amount.to_f / 100)
+          else
+            amount.split('.').first
+          end
+        elsif three_decimal_currency?(currency)
+          if self.money_format == :cents
+            (amount.to_i * 10).to_s
+          else
+            sprintf("%.3f", amount.to_f)
+          end
         end
       end
 

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

@@ -143,6 +143,8 @@ module ActiveMerchant
 
         if response.params["response_reason_code"] == INELIGIBLE_FOR_ISSUING_CREDIT_ERROR
           void(authorization, options)
+        else
+          response
         end
       end
 
@@ -553,11 +555,12 @@ module ActiveMerchant
 
         xml.billTo do
           first_name, last_name = names_from(payment_source, address, options)
+          full_address = "#{address[:address1]} #{address[:address2]}".strip
+
           xml.firstName(truncate(first_name, 50)) unless empty?(first_name)
           xml.lastName(truncate(last_name, 50)) unless empty?(last_name)
-
           xml.company(truncate(address[:company], 50)) unless empty?(address[:company])
-          xml.address(truncate(address[:address1], 60))
+          xml.address(truncate(full_address, 60))
           xml.city(truncate(address[:city], 40))
           xml.state(empty?(address[:state]) ? 'n/a' : truncate(address[:state], 40))
           xml.zip(truncate((address[:zip] || options[:zip]), 20))
@@ -577,12 +580,12 @@ module ActiveMerchant
           else
             [address[:first_name], address[:last_name]]
           end
+          full_address = "#{address[:address1]} #{address[:address2]}".strip
 
           xml.firstName(truncate(first_name, 50)) unless empty?(first_name)
           xml.lastName(truncate(last_name, 50)) unless empty?(last_name)
-
           xml.company(truncate(address[:company], 50)) unless empty?(address[:company])
-          xml.address(truncate(address[:address1], 60))
+          xml.address(truncate(full_address, 60))
           xml.city(truncate(address[:city], 40))
           xml.state(truncate(address[:state], 40))
           xml.zip(truncate(address[:zip], 20))

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

@@ -592,7 +592,8 @@ module ActiveMerchant #:nodoc:
                 :expiration_year => credit_card_or_vault_id.year.to_s,
                 :google_transaction_id => credit_card_or_vault_id.transaction_id,
                 :source_card_type => credit_card_or_vault_id.brand,
-                :source_card_last_four => credit_card_or_vault_id.last_digits
+                :source_card_last_four => credit_card_or_vault_id.last_digits,
+                :eci_indicator => credit_card_or_vault_id.eci
               }
             end
           else

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

@@ -5,7 +5,7 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class CheckoutGateway < Gateway
       self.default_currency = 'USD'
-      self.money_format = :decimals
+      self.money_format = :cents
 
       self.supported_countries = ['AD', 'AT', 'BE', 'BG', 'CH', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FO', 'FI', 'FR', 'GB', 'GI', 'GL', 'GR', 'HR', 'HU', 'IE', 'IS', 'IL', 'IT', 'LI', 'LT', 'LU', 'LV', 'MC', 'MT', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SI', 'SM', 'SK', 'SJ', 'TR', 'VA']
       self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]

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

@@ -17,6 +17,9 @@ module ActiveMerchant #:nodoc:
 
       self.supported_countries = %w(DE GB FR IT ES PL NL BE GR CZ PT SE HU RS AT CH BG DK FI SK NO IE HR BA AL LT MK SI LV EE ME LU MT IS AD MC LI SM)
       self.default_currency = "EUR"
+      self.currencies_without_fractions = %w(CLP JPY KRW PYG VND)
+      self.currencies_with_three_decimal_places = %w(BHD JOD KWD OMR RSD TND)
+
       self.money_format = :cents
       self.supported_cardtypes = [:visa, :master, :maestro]
 
@@ -187,9 +190,11 @@ module ActiveMerchant #:nodoc:
       private
 
       def add_invoice(post, money, options)
-        post[:a4] = amount(money)
+        currency = options[:currency] || currency(money)
+
+        post[:a4] = localized_amount(money, currency)
         post[:a1] = generate_unique_id
-        post[:a5] = options[:currency] || currency(money)
+        post[:a5] = currency
         post[:h9] = options[:order_id]
       end
 

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

@@ -26,7 +26,7 @@ module ActiveMerchant #:nodoc:
 
       XSD_VERSION = "1.121"
 
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :switch, :dankort, :maestro]
       self.supported_countries = %w(US BR CA CN DK FI FR DE JP MX NO SE GB SG LB)
 
       self.default_currency = 'USD'
@@ -39,7 +39,12 @@ module ActiveMerchant #:nodoc:
         :visa  => '001',
         :master => '002',
         :american_express => '003',
-        :discover => '004'
+        :discover => '004',
+        :diners_club => '005',
+        :jcb => '007',
+        :switch => '024',
+        :dankort => '034',
+        :maestro => '042'
       }
 
       @@response_codes = {

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

@@ -3,7 +3,7 @@ require 'nokogiri'
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class FirstPayGateway < Gateway
-      self.live_url = 'https://secure.1stpaygateway.net/secure/gateway/xmlgateway.aspx'
+      self.live_url = 'https://secure.goemerchant.com/secure/gateway/xmlgateway.aspx'
 
       self.supported_countries = ['US']
       self.default_currency = 'USD'
@@ -12,6 +12,7 @@ module ActiveMerchant #:nodoc:
 
       self.homepage_url = 'http://1stpaygateway.net/'
       self.display_name = '1stPayGateway.Net'
+      self.ssl_version = :TLSv1
 
       def initialize(options={})
         requires!(options, :transaction_center_id, :gateway_id)

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

@@ -262,16 +262,13 @@ module ActiveMerchant #:nodoc:
 
       def add_network_tokenization_credit_card(xml, credit_card)
         case card_brand(credit_card).to_sym
-        when :visa
-          xml.tag!("XID", credit_card.transaction_id) if credit_card.transaction_id
-          xml.tag!("CAVV", credit_card.payment_cryptogram)
-        when :mastercard
-          xml.tag!("XID", credit_card.transaction_id) if credit_card.transaction_id
-          xml.tag!("CAVV", credit_card.payment_cryptogram)
         when :american_express
           cryptogram = Base64.decode64(credit_card.payment_cryptogram)
           xml.tag!("XID", Base64.encode64(cryptogram[20...40]))
           xml.tag!("CAVV", Base64.encode64(cryptogram[0...20]))
+        else
+          xml.tag!("XID", credit_card.transaction_id) if credit_card.transaction_id
+          xml.tag!("CAVV", credit_card.payment_cryptogram)
         end
       end
 

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

@@ -153,41 +153,41 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      def purchase(money, credit_card, options = {})
-        commit(money, build_sale_request(money, credit_card, options))
+      def purchase(money, payment, options = {})
+        commit(money, build_sale_request(money, payment, options))
       end
 
-      def authorize(money, credit_card, options = {})
-        commit(money, build_authonly_request(money, credit_card, options))
+      def authorize(money, payment, options = {})
+        commit(money, build_authonly_request(money, payment, options))
       end
 
       def capture(money, reference, options = {})
-        split_authorization = reference.split(";")
-        transaction_id = split_authorization[0]
-        token = split_authorization[3]
-        commit(money, build_capture_request(transaction_id, money, options), token)
+        transaction_id, _, _, token = reference.split(";")
+        commit(money, build_capture_request(money, transaction_id, options), token)
       end
 
       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, options), token)
+        transaction_id, _, amount, token = reference.split(";")
+        commit(amount.to_i, build_void_request(amount.to_i, transaction_id, options), token)
       end
 
-      def credit(money, credit_card, options = {})
-        commit(money, build_credit_request(money, nil, credit_card, nil, options))
+      def credit(money, payment, options = {})
+        commit(money, build_credit_request(money, nil, payment, options))
       end
 
       def refund(money, reference, options = {})
-        split_authorization = reference.split(";")
-        transaction_id = split_authorization[0]
-        token = split_authorization[3]
-        commit(money, build_credit_request(money, transaction_id, nil, token, options))
+        transaction_id, _, _, token = reference.split(";")
+        commit(money, build_credit_request(money, transaction_id, token, options), token)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         authorize(0, credit_card, options)
       end
 
+      def store(credit_card, options = {})
+        commit(nil, build_store_request(credit_card, options))
+      end
+
       def supports_scrubbing
         true
       end
@@ -224,9 +224,9 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def build_sale_request(money, credit_card, options)
+      def build_sale_request(money, payment, options)
         build_xml_request('SALE', options) do |xml|
-          add_credit_card(xml, credit_card)
+          add_payment(xml, payment)
           add_addresses(xml, options)
           add_customer_data(xml, options)
           add_invoice_data(xml, options)
@@ -237,9 +237,9 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def build_authonly_request(money, credit_card, options)
+      def build_authonly_request(money, payment, options)
         build_xml_request('AUTHONLY', options) do |xml|
-          add_credit_card(xml, credit_card)
+          add_payment(xml, payment)
           add_addresses(xml, options)
           add_customer_data(xml, options)
           add_invoice_data(xml, options)
@@ -250,9 +250,10 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def build_capture_request(transaction_id, money, options)
+      def build_capture_request(money, transaction_id, options)
         build_xml_request('CAPT', options, transaction_id) do |xml|
           add_invoice_data(xml, options)
+          add_purchase_order(xml, options)
           add_user_defined_fields(xml, options)
           xml.tag! 'TotalAmount', amount(money)
 
@@ -260,25 +261,31 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def build_void_request(money, transaction_id, approval, token, options)
+      def build_void_request(money, transaction_id, 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
-
           xml.target!
         end
       end
 
-      def build_credit_request(money, transaction_id, card, token, options)
+      def build_credit_request(money, transaction_id, payment, options)
         build_xml_request('CREDIT', options, transaction_id) do |xml|
-          add_credit_card(xml, card) if card
+          add_payment(xml, payment)
           add_invoice_data(xml, options)
           add_addresses(xml, options)
           add_customer_data(xml, options)
           add_user_defined_fields(xml, options)
           xml.tag! 'TotalAmount', amount(money)
-          xml.tag! 'Token', token if token
+
+          xml.target!
+        end
+      end
+
+      def build_store_request(credit_card, options)
+        build_xml_request('TOKENIZE', options) do |xml|
+          add_payment(xml, credit_card)
+          add_addresses(xml, options)
+          add_customer_data(xml, options)
 
           xml.target!
         end
@@ -344,6 +351,18 @@ module ActiveMerchant #:nodoc:
         response[:action_code]
       end
 
+      def add_payment(xml, payment)
+        return unless payment
+
+        if payment.is_a? String
+          token = payment
+          _, _, _, token = payment.split(";") if payment.include? ";"
+          xml.tag! 'Token', token if token
+        else
+          add_credit_card(xml, payment)
+        end
+      end
+
       def add_credit_card(xml, credit_card)
         xml.tag! 'CardNum', credit_card.number, "CardPresent" => false, "Tokenize" => true
         xml.tag! 'CardExpMonth', format_exp(credit_card.month)
@@ -391,7 +410,15 @@ module ActiveMerchant #:nodoc:
       def add_invoice_data(xml, options)
         xml.tag! 'OrderNumber', options[:order_id] if options[:order_id]
         if tax_amount = options[:tax_amount]
-          xml.tag! 'TaxAmount', tax_amount, {'ExemptInd' => options[:tax_exemption] || "false"}
+          xml.tag! 'TaxAmount', tax_amount, {'ExemptInd' => options[:tax_exempt] || "false"}
+        end
+      end
+
+      def add_purchase_order(xml, options)
+        if purchase_order = options[:purchase_order]
+          xml.tag! 'Billing' do
+            xml.tag! 'CustomerPO', purchase_order
+          end
         end
       end
 

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

@@ -181,21 +181,23 @@ module ActiveMerchant #:nodoc:
         sprintf("%.4i", creditcard.year)[-2..-1] + sprintf("%.2i", creditcard.month)
       end
 
-      def add_payment_source(post, source, options)
-        if source.is_a?(String)
-          post[:data_key]   = source
+      def add_payment_source(post, payment_method, options)
+        if payment_method.is_a?(String)
+          post[:data_key]   = payment_method
           post[:cust_id]    = options[:customer]
         else
-          if source.respond_to?(:track_data) && source.track_data.present?
+          if payment_method.respond_to?(:track_data) && payment_method.track_data.present?
             post[:pos_code]   = '00'
-            post[:track2]     = source.track_data
+            post[:track2]     = payment_method.track_data
           else
-            post[:pan]        = source.number
-            post[:expdate]    = expdate(source)
-            post[:cvd_value]  = source.verification_value if source.verification_value?
-            post[:cavv] = source.payment_cryptogram if source.is_a?(NetworkTokenizationCreditCard)
+            post[:pan]        = payment_method.number
+            post[:expdate]    = expdate(payment_method)
+            post[:cvd_value]  = payment_method.verification_value if payment_method.verification_value?
+            post[:cavv] = payment_method.payment_cryptogram if payment_method.is_a?(NetworkTokenizationCreditCard)
+            post[:wallet_indicator] = wallet_indicator(payment_method.source.to_s) if payment_method.is_a?(NetworkTokenizationCreditCard)
+            post[:crypt_type] = (payment_method.eci || 7) if payment_method.is_a?(NetworkTokenizationCreditCard)
           end
-          post[:cust_id] = options[:customer] || source.name
+          post[:cust_id] = options[:customer] || payment_method.name
         end
       end
 
@@ -310,6 +312,12 @@ module ActiveMerchant #:nodoc:
         element
       end
 
+      def wallet_indicator(token_source)
+        return 'APP' if token_source == 'apple_pay'
+        return 'ANP' if token_source == 'android_pay'
+        nil
+      end
+
       def message_from(message)
         return 'Unspecified error' if message.blank?
         message.gsub(/[^\w]/, ' ').split.join(" ").capitalize
@@ -324,8 +332,8 @@ module ActiveMerchant #:nodoc:
           "indrefund"          => [:order_id, :cust_id, :amount, :pan, :expdate, :crypt_type],
           "completion"         => [:order_id, :comp_amount, :txn_number, :crypt_type],
           "purchasecorrection" => [:order_id, :txn_number, :crypt_type],
-          "cavv_preauth"       => [:order_id, :cust_id, :amount, :pan, :expdate, :cavv],
-          "cavv_purchase"      => [:order_id, :cust_id, :amount, :pan, :expdate, :cavv],
+          "cavv_preauth"       => [:order_id, :cust_id, :amount, :pan, :expdate, :cavv, :crypt_type, :wallet_indicator],
+          "cavv_purchase"      => [:order_id, :cust_id, :amount, :pan, :expdate, :cavv, :crypt_type, :wallet_indicator],
           "transact"           => [:order_id, :cust_id, :amount, :pan, :expdate, :crypt_type],
           "Batchcloseall"      => [],
           "opentotals"         => [:ecr_number],

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

@@ -130,10 +130,22 @@ module ActiveMerchant #:nodoc:
             holder_name: creditcard.name
           }
           add_address(card, options)
+          add_customer_data(post, creditcard, options)
           post[:card] = card
         end
       end
 
+      def add_customer_data(post, creditcard, options)
+        if options[:email]
+          customer = {
+            name: creditcard.name || options[:name],
+            email: options[:email]
+          }
+          post[:customer] = customer
+        end
+        post
+      end
+
       def add_address(card, options)
         return unless card.kind_of?(Hash)
         if address = (options[:billing_address] || options[:address])

data/lib/active_merchant/billing/gateways/payflow/payflow_common_api.rb

@@ -180,8 +180,8 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def build_headers(content_length)
-        {
+      def build_headers(content_length, options = {})
+        headers = {
           "Content-Type" => "text/xml",
           "Content-Length" => content_length.to_s,
           "X-VPS-Client-Timeout" => timeout.to_s,
@@ -189,11 +189,14 @@ module ActiveMerchant #:nodoc:
           "X-VPS-VIT-Runtime-Version" => RUBY_VERSION,
           "X-VPS-Request-ID" => SecureRandom.hex(16)
         }
+
+        headers.merge!("PAYPAL-NVP" => options[:paypal_nvp]) if options[:paypal_nvp]
+        headers
       end
 
-      def commit(request_body, options  = {})
+      def commit(request_body, options = {})
         request = build_request(request_body, options)
-        headers = build_headers(request.size)
+        headers = build_headers(request.size, options)
 
         response = parse(ssl_post(test? ? self.test_url : self.live_url, request, headers))
 

data/lib/active_merchant/billing/gateways/quickpay/quickpay_v10.rb

@@ -15,7 +15,7 @@ module ActiveMerchant
       end
 
       def purchase(money, credit_card_or_reference, options = {})
-        MultiResponse.run(true) do |r|
+        MultiResponse.run do |r|
           if credit_card_or_reference.is_a?(String)
             r.process { create_token(credit_card_or_reference, options) }
             credit_card_or_reference = r.authorization
@@ -34,7 +34,7 @@ module ActiveMerchant
       end
 
       def authorize(money, credit_card_or_reference, options = {})
-        MultiResponse.run(true) do |r|
+        MultiResponse.run do |r|
           if credit_card_or_reference.is_a?(String)
             r.process { create_token(credit_card_or_reference, options) }
             credit_card_or_reference = r.authorization
@@ -132,7 +132,6 @@ module ActiveMerchant
 
         def create_token(identification, options)
           post = {}
-          # post[:id] = options[:id]
           commit(synchronized_path("/cards/#{identification}/tokens"), post)
         end
 
@@ -196,7 +195,7 @@ module ActiveMerchant
             post[:shipping_address] = map_address(options[:shipping_address])
           end
 
-          [:metadata, :brading_id, :variables].each do |field|
+          [:metadata, :branding_id, :variables].each do |field|
             post[field] = options[field] if options[field]
           end
         end

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

@@ -24,6 +24,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_transaction_data("Sale", post, money, options)
         add_payment(post, payment)
+        add_customer_details(post, payment, options)
 
         commit(post)
       end
@@ -32,14 +33,15 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_transaction_data("Auth", post, money, options)
         add_payment(post, payment)
+        add_customer_details(post, payment, options)
 
         commit(post)
       end
 
       def capture(money, authorization, options={})
         post = {}
-        add_transaction_data("Settle", post, money, options)
-        auth, transaction_id, token, exp_month, exp_year, _ = authorization.split("|")
+        auth, transaction_id, token, exp_month, exp_year, _, original_currency = authorization.split("|")
+        add_transaction_data("Settle", post, money, (options.merge!({currency: original_currency})))
         post[:sg_AuthCode] = auth
         post[:sg_TransactionID] = transaction_id
         post[:sg_CCToken] = token
@@ -51,8 +53,8 @@ module ActiveMerchant #:nodoc:
 
       def refund(money, authorization, options={})
         post = {}
-        add_transaction_data("Credit", post, money, options)
-        auth, transaction_id, token, exp_month, exp_year, _ = authorization.split("|")
+        auth, transaction_id, token, exp_month, exp_year, _, original_currency = authorization.split("|")
+        add_transaction_data("Credit", post, money, (options.merge!({currency: original_currency})))
         post[:sg_CreditType] = 2
         post[:sg_AuthCode] = auth
         post[:sg_TransactionID] = transaction_id
@@ -74,8 +76,8 @@ module ActiveMerchant #:nodoc:
 
       def void(authorization, options={})
         post = {}
-        auth, transaction_id, token, exp_month, exp_year, original_amount = authorization.split("|")
-        add_transaction_data("Void", post, (original_amount.to_f * 100), options)
+        auth, transaction_id, token, exp_month, exp_year, original_amount, original_currency = authorization.split("|")
+        add_transaction_data("Void", post, (original_amount.to_f * 100), (options.merge!({currency: original_currency})))
         post[:sg_CreditType] = 2
         post[:sg_AuthCode] = auth
         post[:sg_TransactionID] = transaction_id
@@ -125,6 +127,21 @@ module ActiveMerchant #:nodoc:
         post[:sg_CVV2] = payment.verification_value
       end
 
+      def add_customer_details(post, payment, options)
+        if address = options[:billing_address] || options[:address]
+          post[:sg_FirstName] = payment.first_name
+          post[:sg_LastName] = payment.last_name
+          post[:sg_Address] = address[:address1] if address[:address1]
+          post[:sg_City] = address[:city] if address[:city]
+          post[:sg_State] = address[:state]  if address[:state]
+          post[:sg_Zip] = address[:zip]  if address[:zip]
+          post[:sg_Country] = address[:country]  if address[:country]
+          post[:sg_Phone] = address[:phone]  if address[:phone]
+        end
+
+        post[:sg_Email] = options[:email]
+      end
+
       def parse(xml)
         response = {}
 
@@ -177,7 +194,8 @@ module ActiveMerchant #:nodoc:
           response[:token],
           parameters[:sg_ExpMonth],
           parameters[:sg_ExpYear],
-          parameters[:sg_Amount]
+          parameters[:sg_Amount],
+          parameters[:sg_Currency]
         ].join("|")
       end
 

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

@@ -0,0 +1,217 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TrexleGateway < Gateway
+      self.test_url = 'https://core.trexle.com/api/v1'
+      self.live_url = 'https://core.trexle.com/api/v1'
+
+      self.default_currency = 'USD'
+      self.money_format = :cents
+      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.supported_cardtypes = [:visa, :master, :american_express]
+      self.homepage_url = 'https://trexle.com'
+      self.display_name = 'Trexle'
+
+      def initialize(options = {})
+        requires!(options, :api_key)
+        super
+      end
+
+      # Create a charge using a credit card, card token or customer token
+      #
+      # To charge a credit card: purchase([money], [creditcard hash], ...)
+      # To charge a customer: purchase([money], [token], ...)
+      def purchase(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_customer_data(post, options)
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        commit(:post, 'charges', post, options)
+      end
+
+      # Create a customer and associated credit card. The token that is returned
+      # can be used instead of a credit card parameter in the purchase method
+      def store(creditcard, options = {})
+        post = {}
+
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_address(post, creditcard, options)
+        commit(:post, 'customers', post, options)
+      end
+
+      # Refund a transaction
+      def refund(money, token, options = {})
+        commit(:post, "charges/#{CGI.escape(token)}/refunds", { amount: amount(money) }, options)
+      end
+
+      # Authorize an amount on a credit card. Once authorized, you can later
+      # capture this charge using the charge token that is returned.
+      def authorize(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_customer_data(post, options)
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        post[:capture] = false
+        commit(:post, 'charges', post, options)
+      end
+
+      # Captures a previously authorized charge. Capturing only part of the original
+      # authorization is currently not supported.
+      def capture(money, token, options = {})
+        commit(:put, "charges/#{CGI.escape(token)}/capture", { amount: amount(money) }, options)
+      end
+
+      # Updates the credit card for the customer.
+      def update(token, creditcard, options = {})
+        post = {}
+
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_address(post, creditcard, options)
+        commit(:put, "customers/#{CGI.escape(token)}", post, options)
+      end
+
+      def supports_scrubbing
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(/(number\\?":\\?")(\d*)/, '\1[FILTERED]').
+          gsub(/(cvc\\?":\\?")(\d*)/, '\1[FILTERED]')
+      end
+      private
+
+      def add_amount(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:currency] = post[:currency].upcase if post[:currency]
+      end
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email] if options[:email]
+        post[:ip_address] = options[:ip] if options[:ip]
+      end
+
+      def add_address(post, creditcard, options)
+        return if creditcard.kind_of?(String)
+        address = (options[:billing_address] || options[:address])
+        return unless address
+
+        post[:card] ||= {}
+        post[:card].merge!(
+          address_line1: address[:address1],
+          address_line2: address[:address_line2],
+          address_city: address[:city],
+          address_postcode: address[:zip],
+          address_state: address[:state],
+          address_country: address[:country]
+        )
+      end
+
+      def add_invoice(post, options)
+        post[:description] = options[:description] || "Active Merchant Purchase"
+      end
+
+      def add_creditcard(post, creditcard)
+        if creditcard.respond_to?(:number)
+          post[:card] ||= {}
+
+          post[:card].merge!(
+            number: creditcard.number,
+            expiry_month: creditcard.month,
+            expiry_year: creditcard.year,
+            cvc: creditcard.verification_value,
+            name: creditcard.name
+          )
+        elsif creditcard.kind_of?(String)
+          if creditcard =~ /^token_/
+            post[:card_token] = creditcard
+          else
+            post[:customer_token] = creditcard
+          end
+        end
+      end
+
+      def headers(params = {})
+        result = {
+          "Content-Type" => "application/json",
+          "Authorization" => "Basic #{Base64.strict_encode64(options[:api_key] + ':').strip}"
+        }
+
+        result['X-Partner-Key'] = params[:partner_key] if params[:partner_key]
+        result['X-Safe-Card'] = params[:safe_card] if params[:safe_card]
+        result
+      end
+      
+      def commit(method, action, params, options)
+        url = "#{test? ? test_url : live_url}/#{action}"
+        raw_response = ssl_request(method, url, post_data(params), headers(options))
+        parsed_response = parse(raw_response)
+        success_response(parsed_response) 
+      rescue ResponseError => e
+        error_response(parse(e.response.body))
+      rescue JSON::ParserError
+        unparsable_response(raw_response)
+      end
+  
+      def success_response(body)
+        return invalid_response unless body['response']
+      
+        response = body['response']
+        Response.new(
+         true,
+         response['status_message'],
+         body,
+         authorization: token(response),
+         test: test?
+        )
+      end
+
+      def error_response(body)
+        return invalid_response unless body['error']
+        Response.new(
+          false,
+          body['error'],
+          body,
+          authorization: nil,
+          test: test?
+        )
+      end
+
+      def unparsable_response(raw_response)
+        message = "Invalid JSON response received from Trexle. Please contact support@trexle.com 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
+      
+      def invalid_response
+        message = "Invalid response."
+        return Response.new(false, message)
+      end
+
+      def token(response)
+        response['token']
+      end
+
+      def parse(body)
+        return {} if body.blank?
+        JSON.parse(body) 
+      end
+
+      def post_data(parameters = {})
+        parameters.to_json
+      end
+    end
+  end
+end

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = "1.67.0"
+  VERSION = "1.68.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemerchant
 version: !ruby/object:Gem::Version
-  version: 1.67.0
+  version: 1.68.0
 platform: ruby
 authors:
 - Tobias Luetke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-08 00:00:00.000000000 Z
+date: 2017-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -358,6 +358,7 @@ files:
 - lib/active_merchant/billing/gateways/transact_pro.rb
 - lib/active_merchant/billing/gateways/transax.rb
 - lib/active_merchant/billing/gateways/transnational.rb
+- lib/active_merchant/billing/gateways/trexle.rb
 - lib/active_merchant/billing/gateways/trust_commerce.rb
 - lib/active_merchant/billing/gateways/usa_epay.rb
 - lib/active_merchant/billing/gateways/usa_epay_advanced.rb