activemerchant 1.121.0 → 1.125.0

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

@@ -153,6 +153,10 @@ module ActiveMerchant #:nodoc:
         commit(build_refund_request(money, identification, options), :refund, money, options)
       end
 
+      def adjust(money, authorization, options = {})
+        commit(build_adjust_request(money, authorization, options), :adjust, money, options)
+      end
+
       def verify(payment, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(100, payment, options) }
@@ -285,6 +289,7 @@ module ActiveMerchant #:nodoc:
 
       def build_auth_request(money, creditcard_or_reference, options)
         xml = Builder::XmlMarkup.new indent: 2
+        add_customer_id(xml, options)
         add_payment_method_or_subscription(xml, money, creditcard_or_reference, options)
         add_threeds_2_ucaf_data(xml, creditcard_or_reference, options)
         add_decision_manager_fields(xml, options)
@@ -300,7 +305,15 @@ module ActiveMerchant #:nodoc:
         add_merchant_description(xml, options)
         add_sales_slip_number(xml, options)
         add_airline_data(xml, options)
+        xml.target!
+      end
 
+      def build_adjust_request(money, authorization, options)
+        _, request_id = authorization.split(';')
+
+        xml = Builder::XmlMarkup.new indent: 2
+        add_purchase_data(xml, money, true, options)
+        add_incremental_auth_service(xml, request_id, options)
         xml.target!
       end
 
@@ -334,6 +347,7 @@ module ActiveMerchant #:nodoc:
 
       def build_purchase_request(money, payment_method_or_reference, options)
         xml = Builder::XmlMarkup.new indent: 2
+        add_customer_id(xml, options)
         add_payment_method_or_subscription(xml, money, payment_method_or_reference, options)
         add_threeds_2_ucaf_data(xml, payment_method_or_reference, options)
         add_decision_manager_fields(xml, options)
@@ -472,8 +486,8 @@ module ActiveMerchant #:nodoc:
 
         unless network_tokenization?(payment_method)
           xml.tag! 'businessRules' do
-            xml.tag!('ignoreAVSResult', 'true') if extract_option(prioritized_options, :ignore_avs)
-            xml.tag!('ignoreCVResult', 'true') if extract_option(prioritized_options, :ignore_cvv)
+            xml.tag!('ignoreAVSResult', 'true') if extract_option(prioritized_options, :ignore_avs).to_s == 'true'
+            xml.tag!('ignoreCVResult', 'true') if extract_option(prioritized_options, :ignore_cvv).to_s == 'true'
           end
         end
       end
@@ -486,6 +500,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_line_item_data(xml, options)
+        return unless options[:line_items]
+
         options[:line_items].each_with_index do |value, index|
           xml.tag! 'item', { 'id' => index } do
             xml.tag! 'unitPrice', localized_amount(value[:declared_value].to_i, options[:currency] || default_currency)
@@ -493,6 +509,8 @@ module ActiveMerchant #:nodoc:
             xml.tag! 'productCode', value[:code] || 'shipping_only'
             xml.tag! 'productName', value[:description]
             xml.tag! 'productSKU', value[:sku]
+            xml.tag! 'taxAmount', value[:tax_amount] if value[:tax_amount]
+            xml.tag! 'nationalTax', value[:national_tax] if value[:national_tax]
           end
         end
       end
@@ -508,13 +526,21 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_merchant_descriptor(xml, options)
-        return unless options[:merchant_descriptor]
+        return unless options[:merchant_descriptor] || options[:user_po] || options[:taxable]
 
         xml.tag! 'invoiceHeader' do
-          xml.tag! 'merchantDescriptor', options[:merchant_descriptor]
+          xml.tag! 'merchantDescriptor', options[:merchant_descriptor] if options[:merchant_descriptor]
+          xml.tag! 'userPO', options[:user_po] if options[:user_po]
+          xml.tag! 'taxable', options[:taxable] if options[:taxable]
         end
       end
 
+      def add_customer_id(xml, options)
+        return unless options[:customer_id]
+
+        xml.tag! 'customerID', options[:customer_id]
+      end
+
       def add_merchant_description(xml, options)
         return unless options[:merchant_descriptor_name] || options[:merchant_descriptor_address1] || options[:merchant_descriptor_locality]
 
@@ -585,7 +611,7 @@ module ActiveMerchant #:nodoc:
           xml.tag! 'accountNumber', creditcard.number
           xml.tag! 'expirationMonth', format(creditcard.month, :two_digits)
           xml.tag! 'expirationYear', format(creditcard.year, :four_digits)
-          xml.tag!('cvNumber', creditcard.verification_value) unless @options[:ignore_cvv] || creditcard.verification_value.blank?
+          xml.tag!('cvNumber', creditcard.verification_value) unless @options[:ignore_cvv].to_s == 'true' || creditcard.verification_value.blank?
           xml.tag! 'cardType', @@credit_card_codes[card_brand(creditcard).to_sym]
         end
       end
@@ -608,11 +634,12 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_other_tax(xml, options)
-        return unless options[:local_tax_amount] || options[:national_tax_amount]
+        return unless options[:local_tax_amount] || options[:national_tax_amount] || options[:national_tax_indicator]
 
         xml.tag! 'otherTax' do
           xml.tag! 'localTaxAmount', options[:local_tax_amount] if options[:local_tax_amount]
           xml.tag! 'nationalTaxAmount', options[:national_tax_amount] if options[:national_tax_amount]
+          xml.tag! 'nationalTaxIndicator', options[:national_tax_indicator] if options[:national_tax_indicator]
         end
       end
 
@@ -658,6 +685,13 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_incremental_auth_service(xml, authorization, options)
+        xml.tag! 'ccIncrementalAuthService', { 'run' => 'true' } do
+          xml.tag! 'authRequestID', authorization
+        end
+        xml.tag! 'subsequentAuthReason', options[:auth_reason]
+      end
+
       def add_normalized_threeds_2_data(xml, payment_method, options)
         threeds_2_options = options[:three_d_secure]
         cc_brand = card_brand(payment_method).to_sym
@@ -860,6 +894,7 @@ module ActiveMerchant #:nodoc:
         else
           add_address(xml, payment_method_or_reference, options[:billing_address], options)
           add_address(xml, payment_method_or_reference, options[:shipping_address], options, true)
+          add_line_item_data(xml, options)
           add_purchase_data(xml, money, true, options)
           add_installments(xml, options)
           add_creditcard(xml, payment_method_or_reference)

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

@@ -4,7 +4,7 @@ module ActiveMerchant #:nodoc:
       self.test_url = 'https://sandbox.dlocal.com'
       self.live_url = 'https://api.dlocal.com'
 
-      self.supported_countries = %w[AR BR CL CO MX PE UY TR]
+      self.supported_countries = %w[AR BD BO BR CL CM CN CO CR DO EC EG GH IN ID KE MY MX MA NG PA PY PE PH SN ZA TR UY VN]
       self.default_currency = 'USD'
       self.supported_cardtypes = %i[visa master american_express discover jcb diners_club maestro naranja cabal elo alia carnet]
 
@@ -26,6 +26,7 @@ module ActiveMerchant #:nodoc:
       def authorize(money, payment, options = {})
         post = {}
         add_auth_purchase_params(post, money, payment, 'authorize', options)
+        post[:card][:verify] = true if options[:verify].to_s == 'true'
 
         commit('authorize', post, options)
       end
@@ -52,10 +53,7 @@ module ActiveMerchant #:nodoc:
       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
+        authorize(0, credit_card, options.merge(verify: 'true'))
       end
 
       def supports_scrubbing?
@@ -78,6 +76,7 @@ module ActiveMerchant #:nodoc:
         add_country(post, card, options)
         add_payer(post, card, options)
         add_card(post, card, action, options)
+        add_additional_data(post, options)
         post[:order_id] = options[:order_id] || generate_unique_id
         post[:description] = options[:description] if options[:description]
       end
@@ -87,6 +86,10 @@ module ActiveMerchant #:nodoc:
         post[:currency] = (options[:currency] || currency(money))
       end
 
+      def add_additional_data(post, options)
+        post[:additional_risk_data] = options[:additional_data]
+      end
+
       def add_country(post, card, options)
         return unless address = options[:billing_address] || options[:address]
 
@@ -109,6 +112,8 @@ module ActiveMerchant #:nodoc:
         post[:payer][:document] = options[:document] if options[:document]
         post[:payer][:document2] = options[:document2] if options[:document2]
         post[:payer][:user_reference] = options[:user_reference] if options[:user_reference]
+        post[:payer][:event_uuid] = options[:device_id] if options[:device_id]
+        post[:payer][:onboarding_ip_address] = options[:ip] if options[:ip]
         post[:payer][:address] = add_address(post, card, options)
       end
 
@@ -184,7 +189,7 @@ module ActiveMerchant #:nodoc:
       def success_from(action, response)
         return false unless response['status_code']
 
-        %w[100 200 400 600].include? response['status_code'].to_s
+        %w[100 200 400 600 700].include? response['status_code'].to_s
       end
 
       def message_from(action, response)
@@ -228,6 +233,7 @@ module ActiveMerchant #:nodoc:
           'X-Date' => timestamp,
           'X-Login' => @options[:login],
           'X-Trans-Key' => @options[:trans_key],
+          'X-Version' => '2.1',
           'Authorization' => signature(post, timestamp)
         }
         headers.merge('X-Idempotency-Key' => options[:idempotency_key]) if options[:idempotency_key]

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

@@ -282,7 +282,13 @@ module ActiveMerchant #:nodoc:
         if error = response.dig('status_details', 'error')
           message = "#{error.dig('reason', 'description')} | #{error['type']}"
         elsif response['error_type']
-          message = response['validation_errors'].map { |errors| "#{errors['code']}: #{errors['param']}" }.join(', ') if response['validation_errors']
+          if response['validation_errors'].is_a?(Array)
+            message = response['validation_errors'].map { |errors| "#{errors['code']}: #{errors['param']}" }.join(', ')
+          elsif response['validation_errors'].is_a?(Hash)
+            errors = response['validation_errors'].map { |k, v| "#{k}: #{v}" }.join(', ')
+            message = "#{response['error_type']} - #{errors}"
+          end
+
           message ||= response['error_type']
         end
 

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

@@ -0,0 +1,173 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class DecidirPlusGateway < Gateway
+      self.test_url = 'https://developers.decidir.com/api/v2'
+      self.live_url = 'https://live.decidir.com/api/v2'
+
+      self.supported_countries = ['AR']
+      self.default_currency = 'ARS'
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'http://decidir.com.ar/home'
+      self.display_name = 'Decidir Plus'
+
+      def initialize(options = {})
+        requires!(options, :public_key, :private_key)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+
+        add_payment(post, payment, options)
+        add_purchase_data(post, money, payment, options)
+
+        commit(:post, 'payments', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        post[:amount] = money
+
+        commit(:post, "payments/#{add_reference(authorization)}/refunds")
+      end
+
+      def store(payment, options = {})
+        post = {}
+        add_payment(post, payment, options)
+
+        commit(:post, 'tokens', post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Apikey: )\w+), '\1[FILTERED]').
+          gsub(%r(("card_number\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("security_code\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      def add_reference(authorization)
+        return unless authorization
+
+        authorization.split('|')[0]
+      end
+
+      def add_payment(post, payment, options = {})
+        if payment.is_a?(String)
+          token, bin = payment.split('|')
+          post[:token] = token
+          post[:bin] = bin
+        else
+          post[:card_number] = payment.number
+          post[:card_expiration_month] = payment.month.to_s.rjust(2, '0')
+          post[:card_expiration_year] = payment.year.to_s[-2..-1]
+          post[:security_code] = payment.verification_value.to_s
+          post[:card_holder_name] = payment.name
+          post[:card_holder_identification] = {}
+          post[:card_holder_identification][:type] = options[:dni]
+          post[:card_holder_identification][:number] = options[:card_holder_identification_number]
+        end
+      end
+
+      def add_purchase_data(post, money, payment, options = {})
+        post[:site_transaction_id] = options[:site_transaction_id] || SecureRandom.hex
+        post[:payment_method_id] = 1
+        post[:amount] = money
+        post[:currency] = options[:currency] || self.default_currency
+        post[:installments] = options[:installments] || 1
+        post[:payment_type] = options[:payment_type] || 'single'
+        add_sub_payments(post, options)
+      end
+
+      def add_sub_payments(post, options)
+        # sub_payments field is required for purchase transactions, even if empty
+        post[:sub_payments] = []
+
+        return unless sub_payments = options[:sub_payments]
+
+        sub_payments.each do |sub_payment|
+          sub_payment_hash = {
+            site_id: sub_payment[:site_id],
+            installments: sub_payment[:installments],
+            amount: sub_payment[:amount]
+          }
+          post[:sub_payments] << sub_payment_hash
+        end
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(method, endpoint, parameters = {}, options = {})
+        begin
+          raw_response = ssl_request(method, url(endpoint), post_data(parameters), headers(endpoint))
+          response = parse(raw_response)
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response = parse(raw_response)
+        end
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          avs_result: AVSResult.new(code: response['some_avs_response_key']),
+          cvv_result: CVVResult.new(response['some_cvv_response_key']),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def headers(endpoint)
+        {
+          'Content-Type' => 'application/json',
+          'apikey' => endpoint == 'tokens' ? @options[:public_key] : @options[:private_key]
+        }
+      end
+
+      def url(action, options = {})
+        base_url = (test? ? test_url : live_url)
+
+        return "#{base_url}/#{action}"
+      end
+
+      def success_from(response)
+        response.dig('status') == 'approved' || response.dig('status') == 'active'
+      end
+
+      def message_from(response)
+        response.dig('status') || error_message(response) || response.dig('message')
+      end
+
+      def authorization_from(response)
+        return nil unless response.dig('id') || response.dig('bin')
+
+        "#{response.dig('id')}|#{response.dig('bin')}"
+      end
+
+      def post_data(parameters = {})
+        parameters.to_json
+      end
+
+      def error_code_from(response)
+        response.dig('error_type') unless success_from(response)
+      end
+
+      def error_message(response)
+        return error_code_from(response) unless validation_errors = response.dig('validation_errors')
+
+        validation_errors = validation_errors[0]
+
+        "#{validation_errors.dig('code')}: #{validation_errors.dig('param')}"
+      end
+    end
+  end
+end

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

@@ -214,6 +214,7 @@ module ActiveMerchant #:nodoc:
         post[:metadata] = options[:metadata] if options[:metadata]
         post[:metadata] = {} if post[:metadata].nil?
         post[:metadata][:merchant_payment_code] = options[:order_id] if options[:order_id]
+        post[:processing_type] = options[:processing_type] if options[:processing_type]
       end
 
       def parse(body)
@@ -222,7 +223,8 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, parameters)
         url = url_for((test? ? test_url : live_url), action, parameters)
-        response = parse(ssl_request(HTTP_METHOD[action], url, post_data(action, parameters), { 'x-ebanx-client-user-agent': "ActiveMerchant/#{ActiveMerchant::VERSION}" }))
+
+        response = parse(ssl_request(HTTP_METHOD[action], url, post_data(action, parameters), headers(parameters)))
 
         success = success_from(action, response)
 
@@ -236,6 +238,19 @@ module ActiveMerchant #:nodoc:
         )
       end
 
+      def headers(params)
+        processing_type = params[:processing_type]
+        commit_headers = { 'x-ebanx-client-user-agent': "ActiveMerchant/#{ActiveMerchant::VERSION}" }
+
+        add_processing_type_to_commit_headers(commit_headers, processing_type) if processing_type == 'local'
+
+        commit_headers
+      end
+
+      def add_processing_type_to_commit_headers(commit_headers, processing_type)
+        commit_headers['x-ebanx-api-processing-type'] = processing_type
+      end
+
       def success_from(action, response)
         if %i[purchase capture refund].include?(action)
           response.try(:[], 'payment').try(:[], 'status') == 'CO'

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

@@ -201,8 +201,8 @@ module ActiveMerchant #:nodoc:
       private
 
       def add_invoice(xml, options)
-        xml.ssl_invoice_number    truncate((options[:order_id] || options[:invoice]), 25)
-        xml.ssl_description       truncate(options[:description], 255)
+        xml.ssl_invoice_number    url_encode_truncate((options[:order_id] || options[:invoice]), 25)
+        xml.ssl_description       url_encode_truncate(options[:description], 255)
       end
 
       def add_approval_code(xml, authorization)
@@ -219,8 +219,8 @@ module ActiveMerchant #:nodoc:
 
         add_verification_value(xml, creditcard) if creditcard.verification_value?
 
-        xml.ssl_first_name    truncate(creditcard.first_name, 20)
-        xml.ssl_last_name     truncate(creditcard.last_name, 30)
+        xml.ssl_first_name    url_encode_truncate(creditcard.first_name, 20)
+        xml.ssl_last_name     url_encode_truncate(creditcard.last_name, 30)
       end
 
       def add_currency(xml, money, options)
@@ -240,7 +240,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_customer_email(xml, options)
-        xml.ssl_email truncate(options[:email], 100) unless empty?(options[:email])
+        xml.ssl_email url_encode_truncate(options[:email], 100) unless empty?(options[:email])
       end
 
       def add_salestax(xml, options)
@@ -253,27 +253,27 @@ module ActiveMerchant #:nodoc:
         billing_address = options[:billing_address] || options[:address]
 
         if billing_address
-          xml.ssl_avs_address     truncate(billing_address[:address1], 30)
-          xml.ssl_address2        truncate(billing_address[:address2], 30)
-          xml.ssl_avs_zip         truncate(billing_address[:zip].to_s.gsub(/[^a-zA-Z0-9]/, ''), 9)
-          xml.ssl_city            truncate(billing_address[:city], 30)
-          xml.ssl_state           truncate(billing_address[:state], 10)
-          xml.ssl_company         truncate(billing_address[:company], 50)
-          xml.ssl_phone           truncate(billing_address[:phone], 20)
-          xml.ssl_country         truncate(billing_address[:country], 50)
+          xml.ssl_avs_address     url_encode_truncate(billing_address[:address1], 30)
+          xml.ssl_address2        url_encode_truncate(billing_address[:address2], 30)
+          xml.ssl_avs_zip         url_encode_truncate(billing_address[:zip].to_s.gsub(/[^a-zA-Z0-9]/, ''), 9)
+          xml.ssl_city            url_encode_truncate(billing_address[:city], 30)
+          xml.ssl_state           url_encode_truncate(billing_address[:state], 10)
+          xml.ssl_company         url_encode_truncate(billing_address[:company], 50)
+          xml.ssl_phone           url_encode_truncate(billing_address[:phone], 20)
+          xml.ssl_country         url_encode_truncate(billing_address[:country], 50)
         end
 
         if shipping_address = options[:shipping_address]
-          xml.ssl_ship_to_address1    truncate(shipping_address[:address1], 30)
-          xml.ssl_ship_to_address2    truncate(shipping_address[:address2], 30)
-          xml.ssl_ship_to_city        truncate(shipping_address[:city], 30)
-          xml.ssl_ship_to_company     truncate(shipping_address[:company], 50)
-          xml.ssl_ship_to_country     truncate(shipping_address[:country], 50)
-          xml.ssl_ship_to_first_name  truncate(shipping_address[:first_name], 20)
-          xml.ssl_ship_to_last_name   truncate(shipping_address[:last_name], 30)
-          xml.ssl_ship_to_phone       truncate(shipping_address[:phone], 10)
-          xml.ssl_ship_to_state       truncate(shipping_address[:state], 2)
-          xml.ssl_ship_to_zip         truncate(shipping_address[:zip], 10)
+          xml.ssl_ship_to_address1    url_encode_truncate(shipping_address[:address1], 30)
+          xml.ssl_ship_to_address2    url_encode_truncate(shipping_address[:address2], 30)
+          xml.ssl_ship_to_city        url_encode_truncate(shipping_address[:city], 30)
+          xml.ssl_ship_to_company     url_encode_truncate(shipping_address[:company], 50)
+          xml.ssl_ship_to_country     url_encode_truncate(shipping_address[:country], 50)
+          xml.ssl_ship_to_first_name  url_encode_truncate(shipping_address[:first_name], 20)
+          xml.ssl_ship_to_last_name   url_encode_truncate(shipping_address[:last_name], 30)
+          xml.ssl_ship_to_phone       url_encode_truncate(shipping_address[:phone], 10)
+          xml.ssl_ship_to_state       url_encode_truncate(shipping_address[:state], 2)
+          xml.ssl_ship_to_zip         url_encode_truncate(shipping_address[:zip], 10)
         end
       end
 
@@ -293,9 +293,12 @@ module ActiveMerchant #:nodoc:
         xml.ssl_cardholder_ip options[:ip] if options.has_key?(:ip)
       end
 
+      # add_recurring_token is a field that can be sent in to obtain a token from Elavon for use with their tokenization program
       def add_auth_purchase_params(xml, options)
         xml.ssl_dynamic_dba                     options[:dba] if options.has_key?(:dba)
         xml.ssl_merchant_initiated_unscheduled  merchant_initiated_unscheduled(options) if merchant_initiated_unscheduled(options)
+        xml.ssl_add_token                       options[:add_recurring_token] if options.has_key?(:add_recurring_token)
+        xml.ssl_token                           options[:ssl_token] if options[:ssl_token]
         xml.ssl_customer_code                   options[:customer] if options.has_key?(:customer)
         xml.ssl_customer_number                 options[:customer_number] if options.has_key?(:customer_number)
         xml.ssl_entry_mode                      entry_mode(options) if entry_mode(options)
@@ -367,7 +370,7 @@ module ActiveMerchant #:nodoc:
 
       def merchant_initiated_unscheduled(options)
         return options[:merchant_initiated_unscheduled] if options[:merchant_initiated_unscheduled]
-        return 'Y' if options.dig(:stored_credential, :initiator) == 'merchant' && options.dig(:stored_credential, :reason_type) == 'unscheduled'
+        return 'Y' if options.dig(:stored_credential, :initiator) == 'merchant' && options.dig(:stored_credential, :reason_type) == 'unscheduled' || options.dig(:stored_credential, :reason_type) == 'recurring'
       end
 
       def entry_mode(options)
@@ -390,15 +393,17 @@ module ActiveMerchant #:nodoc:
 
       def commit(request)
         request = "xmldata=#{request}".delete('&')
+        store_action = request.match?('CCGETTOKEN')
 
         response = parse(ssl_post(test? ? self.test_url : self.live_url, request, headers))
+        response = hash_html_decode(response)
 
         Response.new(
           response[:result] == '0',
           response[:result_message] || response[:errorMessage],
           response,
           test: @options[:test] || test?,
-          authorization: authorization_from(response),
+          authorization: authorization_from(response, store_action),
           error_code: response[:errorCode],
           avs_result: { code: response[:avs_response] },
           cvv_result: response[:cvv2_response],
@@ -413,7 +418,7 @@ module ActiveMerchant #:nodoc:
       def headers
         {
           'Accept' => 'application/xml',
-          'Content-type' => 'application/x-www-form-urlencoded'
+          'Content-type' => 'application/x-www-form-urlencoded;charset=utf8'
         }
       end
 
@@ -424,16 +429,46 @@ module ActiveMerchant #:nodoc:
         response.deep_transform_keys { |key| key.gsub('ssl_', '').to_sym }
       end
 
-      def authorization_from(response)
+      def authorization_from(response, store_action)
+        return response[:token] if store_action
+
         [response[:approval_code], response[:txn_id]].join(';')
       end
 
-      def truncate(value, size)
+      def url_encode_truncate(value, size)
         return nil unless value
 
-        difference = value.force_encoding('iso-8859-1').length - value.length
+        encoded = url_encode(value)
+
+        while encoded.length > size
+          value.chop!
+          encoded = url_encode(value)
+        end
+        encoded
+      end
+
+      def url_encode(value)
+        if value.is_a?(String)
+          encoded = CGI.escape(value)
+          encoded = encoded.tr('+', ' ') # don't encode spaces
+          encoded = encoded.gsub('%26', '%26amp;') # account for Elavon's weird '&' handling
+          encoded
+        else
+          value.to_s
+        end
+      end
 
-        return value.delete('&"<>').to_s[0, (size - difference)]
+      def hash_html_decode(hash)
+        hash.each do |k, v|
+          if v.is_a?(String)
+            # decode all string params
+            v = v.gsub('&amp;amp;', '&amp;') # account for Elavon's weird '&' handling
+            hash[k] = CGI.unescape_html(v)
+          elsif v.is_a?(Hash)
+            hash_html_decode(v)
+          end
+        end
+        hash
       end
     end
   end

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

@@ -82,6 +82,19 @@ module ActiveMerchant #:nodoc:
         commit('CreditCardReturn', request, money)
       end
 
+      def credit(money, payment, options = {})
+        request = build_soap_request do |xml|
+          xml.CreditCardCredit(xmlns: 'https://transaction.elementexpress.com') do
+            add_credentials(xml)
+            add_payment_method(xml, payment)
+            add_transaction(xml, money, options)
+            add_terminal(xml, options)
+          end
+        end
+
+        commit('CreditCardCredit', request, money)
+      end
+
       def void(authorization, options = {})
         trans_id, trans_amount = split_authorization(authorization)
         options.merge!({ trans_id: trans_id, trans_amount: trans_amount, reversal_type: 'Full' })
@@ -186,15 +199,22 @@ module ActiveMerchant #:nodoc:
           xml.ReversalType options[:reversal_type] if options[:reversal_type]
           xml.TransactionID options[:trans_id] if options[:trans_id]
           xml.TransactionAmount amount(money.to_i) if money
-          xml.MarketCode 'Default' if money
+          xml.MarketCode market_code(money, options) if options[:market_code] || money
           xml.ReferenceNumber options[:order_id] || SecureRandom.hex(20)
-
+          xml.TicketNumber options[:ticket_number] if options[:ticket_number]
+          xml.MerchantSuppliedTransactionId options[:merchant_supplied_transaction_id] if options[:merchant_supplied_transaction_id]
           xml.PaymentType options[:payment_type] if options[:payment_type]
           xml.SubmissionType options[:submission_type] if options[:submission_type]
           xml.DuplicateCheckDisableFlag options[:duplicate_check_disable_flag].to_s == 'true' ? 'True' : 'False' unless options[:duplicate_check_disable_flag].nil?
+          xml.DuplicateOverrideFlag options[:duplicate_override_flag].to_s == 'true' ? 'True' : 'False' unless options[:duplicate_override_flag].nil?
+          xml.MerchantDescriptor options[:merchant_descriptor] if options[:merchant_descriptor]
         end
       end
 
+      def market_code(money, options)
+        options[:market_code] || 'Default'
+      end
+
       def add_terminal(xml, options)
         xml.terminal do
           xml.TerminalID options[:terminal_id] || '01'