activemerchant 1.79.2 → 1.129.0

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

@@ -11,8 +11,8 @@ module ActiveMerchant #:nodoc:
       POST_LIVE_URL = 'https://api.merchantwarrior.com/post/'
 
       self.supported_countries = ['AU']
-      self.supported_cardtypes = [:visa, :master, :american_express,
-                                  :diners_club, :discover, :jcb]
+      self.supported_cardtypes = %i[visa master american_express
+                                    diners_club discover jcb]
       self.homepage_url = 'https://www.merchantwarrior.com/'
       self.display_name = 'Merchant Warrior'
 
@@ -30,6 +30,8 @@ module ActiveMerchant #:nodoc:
         add_order_id(post, options)
         add_address(post, options)
         add_payment_method(post, payment_method)
+        add_recurring_flag(post, options)
+        add_soft_descriptors(post, options)
         commit('processAuth', post)
       end
 
@@ -39,6 +41,8 @@ module ActiveMerchant #:nodoc:
         add_order_id(post, options)
         add_address(post, options)
         add_payment_method(post, payment_method)
+        add_recurring_flag(post, options)
+        add_soft_descriptors(post, options)
         commit('processCard', post)
       end
 
@@ -46,7 +50,8 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_amount(post, money, options)
         add_transaction(post, identification)
-        post.merge!('captureAmount' => amount(money))
+        add_soft_descriptors(post, options)
+        post['captureAmount'] = amount(money)
         commit('processCapture', post)
       end
 
@@ -54,10 +59,21 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_amount(post, money, options)
         add_transaction(post, identification)
+        add_soft_descriptors(post, options)
         post['refundAmount'] = amount(money)
         commit('refundCard', post)
       end
 
+      def void(identification, options = {})
+        post = {}
+        # The amount parameter is required for void transactions
+        # on the Merchant Warrior gateway.
+        post['transactionAmount'] = options[:amount]
+        post['hash'] = void_verification_hash(identification)
+        add_transaction(post, identification)
+        commit('processVoid', post)
+      end
+
       def store(creditcard, options = {})
         post = {
           'cardName' => scrub_name(creditcard.name),
@@ -87,7 +103,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_address(post, options)
-        return unless(address = (options[:billing_address] || options[:address]))
+        return unless (address = (options[:billing_address] || options[:address]))
 
         post['customerName'] = scrub_name(address[:name])
         post['customerCountry'] = address[:country]
@@ -119,7 +135,7 @@ module ActiveMerchant #:nodoc:
       def add_creditcard(post, creditcard)
         post['paymentCardNumber'] = creditcard.number
         post['paymentCardName'] = scrub_name(creditcard.name)
-        post['paymentCardExpiry'] = creditcard.expiry_date.expiration.strftime("%m%y")
+        post['paymentCardExpiry'] = creditcard.expiry_date.expiration.strftime('%m%y')
         post['paymentCardCSC'] = creditcard.verification_value if creditcard.verification_value?
       end
 
@@ -135,6 +151,18 @@ module ActiveMerchant #:nodoc:
         post['hash'] = verification_hash(amount(money), currency)
       end
 
+      def add_recurring_flag(post, options)
+        return if options[:recurring_flag].nil?
+
+        post['recurringFlag'] = options[:recurring_flag]
+      end
+
+      def add_soft_descriptors(post, options)
+        post['descriptorName'] = options[:descriptor_name] if options[:descriptor_name]
+        post['descriptorCity'] = options[:descriptor_city] if options[:descriptor_city]
+        post['descriptorState'] = options[:descriptor_state] if options[:descriptor_state]
+      end
+
       def verification_hash(money, currency)
         Digest::MD5.hexdigest(
           (
@@ -146,9 +174,21 @@ module ActiveMerchant #:nodoc:
         )
       end
 
+      def void_verification_hash(transaction_id)
+        Digest::MD5.hexdigest(
+          (
+            @options[:api_passphrase].to_s +
+            @options[:merchant_uuid].to_s +
+            transaction_id
+          ).downcase
+        )
+      end
+
       def parse(body)
         xml = REXML::Document.new(body)
 
+        return { response_message: 'Invalid gateway response' } unless xml.root.present?
+
         response = {}
         xml.root.elements.to_a.each do |node|
           parse_element(response, node)
@@ -158,7 +198,7 @@ module ActiveMerchant #:nodoc:
 
       def parse_element(response, node)
         if node.has_elements?
-          node.elements.each{|element| parse_element(response, element)}
+          node.elements.each { |element| parse_element(response, element) }
         else
           response[node.name.underscore.to_sym] = node.text
         end
@@ -173,29 +213,27 @@ module ActiveMerchant #:nodoc:
           success?(response),
           response[:response_message],
           response,
-          :test => test?,
-          :authorization => (response[:card_id] || response[:transaction_id])
+          test: test?,
+          authorization: (response[:card_id] || response[:transaction_id])
         )
       end
 
       def add_auth(action, post)
         post['merchantUUID'] = @options[:merchant_uuid]
         post['apiKey'] = @options[:api_key]
-        unless token?(post)
-          post['method'] = action
-        end
+        post['method'] = action unless token?(post)
       end
 
       def url_for(action, post)
         if token?(post)
-          [(test? ? TOKEN_TEST_URL : TOKEN_LIVE_URL), action].join("/")
+          [(test? ? TOKEN_TEST_URL : TOKEN_LIVE_URL), action].join('/')
         else
           (test? ? POST_TEST_URL : POST_LIVE_URL)
         end
       end
 
       def token?(post)
-        (post["cardID"] || post["cardName"])
+        (post['cardID'] || post['cardName'])
       end
 
       def success?(response)
@@ -203,7 +241,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def post_data(post)
-        post.collect{|k,v| "#{k}=#{CGI.escape(v.to_s)}" }.join("&")
+        post.collect { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
       end
     end
   end

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

@@ -12,14 +12,14 @@ module ActiveMerchant #:nodoc:
     # and +refund+ will become mandatory.
     class MercuryGateway < Gateway
       URLS = {
-        :test => 'https://w1.mercurycert.net/ws/ws.asmx',
-        :live => 'https://w1.mercurypay.com/ws/ws.asmx'
+        test: 'https://w1.mercurycert.net/ws/ws.asmx',
+        live: 'https://w1.mercurypay.com/ws/ws.asmx'
       }
 
       self.homepage_url = 'http://www.mercurypay.com'
       self.display_name = 'Mercury'
-      self.supported_countries = ['US','CA']
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+      self.supported_countries = %w[US CA]
+      self.supported_cardtypes = %i[visa master american_express discover diners_club jcb]
       self.default_currency = 'USD'
 
       STANDARD_ERROR_CODE_MAPPING = {
@@ -51,14 +51,14 @@ module ActiveMerchant #:nodoc:
       def authorize(money, credit_card, options = {})
         requires!(options, :order_id)
 
-        request = build_non_authorized_request('PreAuth', money, credit_card, options.merge(:authorized => money))
+        request = build_non_authorized_request('PreAuth', money, credit_card, options.merge(authorized: money))
         commit('PreAuth', request)
       end
 
       def capture(money, authorization, options = {})
         requires!(options, :credit_card) unless @use_tokenization
 
-        request = build_authorized_request('PreAuthCapture', money, authorization, options[:credit_card], options.merge(:authorized => money))
+        request = build_authorized_request('PreAuthCapture', money, authorization, options[:credit_card], options.merge(authorized: money))
         commit('PreAuthCapture', request)
       end
 
@@ -69,14 +69,14 @@ module ActiveMerchant #:nodoc:
         commit('Return', request)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         requires!(options, :credit_card) unless @use_tokenization
 
         request = build_authorized_request('VoidSale', nil, authorization, options[:credit_card], options)
         commit('VoidSale', request)
       end
 
-      def store(credit_card, options={})
+      def store(credit_card, options = {})
         request = build_card_lookup_request(credit_card, options)
         commit('CardLookup', request)
       end
@@ -87,8 +87,8 @@ module ActiveMerchant #:nodoc:
 
       def scrub(transcript)
         transcript.
-          gsub(%r(&lt;), "<").
-          gsub(%r(&gt;), ">").
+          gsub(%r(&lt;), '<').
+          gsub(%r(&gt;), '>').
           gsub(%r((<pw>).*(</pw>))i, '\1[FILTERED]\2').
           gsub(%r((<AcctNo>)(\d|x)*(</AcctNo>))i, '\1[FILTERED]\3').
           gsub(%r((<CVVData>)\d*(</CVVData>))i, '\1[FILTERED]\2')
@@ -99,15 +99,13 @@ module ActiveMerchant #:nodoc:
       def build_non_authorized_request(action, money, credit_card, options)
         xml = Builder::XmlMarkup.new
 
-        xml.tag! "TStream" do
-          xml.tag! "Transaction" do
+        xml.tag! 'TStream' do
+          xml.tag! 'Transaction' do
             xml.tag! 'TranType', 'Credit'
             xml.tag! 'TranCode', action
-            if options[:allow_partial_auth] && (action == 'PreAuth' || action == 'Sale')
-              xml.tag! "PartialAuth", "Allow"
-            end
+            xml.tag! 'PartialAuth', 'Allow' if options[:allow_partial_auth] && %w[PreAuth Sale].include?(action)
             add_invoice(xml, options[:order_id], nil, options)
-            add_reference(xml, "RecordNumberRequested")
+            add_reference(xml, 'RecordNumberRequested')
             add_customer_data(xml, options)
             add_amount(xml, money, options)
             add_credit_card(xml, credit_card, action)
@@ -121,15 +119,13 @@ module ActiveMerchant #:nodoc:
         xml = Builder::XmlMarkup.new
 
         invoice_no, ref_no, auth_code, acq_ref_data, process_data, record_no, amount = split_authorization(authorization)
-        ref_no = "1" if ref_no.blank?
+        ref_no = '1' if ref_no.blank?
 
-        xml.tag! "TStream" do
-          xml.tag! "Transaction" do
+        xml.tag! 'TStream' do
+          xml.tag! 'Transaction' do
             xml.tag! 'TranType', 'Credit'
-            if options[:allow_partial_auth] && (action == 'PreAuthCapture')
-              xml.tag! "PartialAuth", "Allow"
-            end
-            xml.tag! 'TranCode', (@use_tokenization ? (action + "ByRecordNo") : action)
+            xml.tag! 'PartialAuth', 'Allow' if options[:allow_partial_auth] && (action == 'PreAuthCapture')
+            xml.tag! 'TranCode', (@use_tokenization ? (action + 'ByRecordNo') : action)
             add_invoice(xml, invoice_no, ref_no, options)
             add_reference(xml, record_no)
             add_customer_data(xml, options)
@@ -137,9 +133,9 @@ module ActiveMerchant #:nodoc:
             add_credit_card(xml, credit_card, action) if credit_card
             add_address(xml, options)
             xml.tag! 'TranInfo' do
-              xml.tag! "AuthCode", auth_code
-              xml.tag! "AcqRefData", acq_ref_data
-              xml.tag! "ProcessData", process_data
+              xml.tag! 'AuthCode', auth_code
+              xml.tag! 'AcqRefData', acq_ref_data
+              xml.tag! 'ProcessData', process_data
             end
           end
         end
@@ -149,8 +145,8 @@ module ActiveMerchant #:nodoc:
       def build_card_lookup_request(credit_card, options)
         xml = Builder::XmlMarkup.new
 
-        xml.tag! "TStream" do
-          xml.tag! "Transaction" do
+        xml.tag! 'TStream' do
+          xml.tag! 'Transaction' do
             xml.tag! 'TranType', 'CardLookup'
             xml.tag! 'RecordNo', 'RecordNumberRequested'
             xml.tag! 'Frequency', 'OneTime'
@@ -172,15 +168,15 @@ module ActiveMerchant #:nodoc:
 
       def add_reference(xml, record_no)
         if @use_tokenization
-          xml.tag! "Frequency", "OneTime"
-          xml.tag! "RecordNo", record_no
+          xml.tag! 'Frequency', 'OneTime'
+          xml.tag! 'RecordNo', record_no
         end
       end
 
       def add_customer_data(xml, options)
         xml.tag! 'IpAddress', options[:ip] if options[:ip]
         if options[:customer]
-          xml.tag! "TranInfo" do
+          xml.tag! 'TranInfo' do
             xml.tag! 'CustomerCode', options[:customer]
           end
         end
@@ -212,14 +208,14 @@ module ActiveMerchant #:nodoc:
             # Track 1 and 2 have identical end sentinels (ETX) of '?'
             # Tracks may or may not have checksum (LRC) after the ETX
             # If the track has no STX or is corrupt, we send it as track 1, to let Mercury
-            #handle with the validation error as it sees fit.
+            # handle with the validation error as it sees fit.
             # Track 2 requires having the STX and ETX stripped. Track 1 does not.
             # Max-length track 1s require having the STX and ETX stripped. Max is 79 bytes including LRC.
-            is_track_2 = credit_card.track_data[0] == ';'
+            is_track2 = credit_card.track_data[0] == ';'
             etx_index = credit_card.track_data.rindex('?') || credit_card.track_data.length
             is_max_track1 = etx_index >= 77
 
-            if is_track_2
+            if is_track2
               xml.tag! 'Track2', credit_card.track_data[1...etx_index]
             elsif is_max_track1
               xml.tag! 'Track1', credit_card.track_data[1...etx_index]
@@ -234,7 +230,7 @@ module ActiveMerchant #:nodoc:
         xml.tag! 'CardType', CARD_CODES[credit_card.brand] if credit_card.brand
 
         include_cvv = !%w(Return PreAuthCapture).include?(action) && !credit_card.track_data.present?
-        xml.tag! 'CVVData', credit_card.verification_value if(include_cvv && credit_card.verification_value)
+        xml.tag! 'CVVData', credit_card.verification_value if include_cvv && credit_card.verification_value
       end
 
       def add_address(xml, options)
@@ -255,12 +251,12 @@ module ActiveMerchant #:nodoc:
       def hashify_xml!(xml, response)
         xml = REXML::Document.new(xml)
 
-        xml.elements.each("//CmdResponse/*") do |node|
+        xml.elements.each('//CmdResponse/*') do |node|
           response[node.name.underscore.to_sym] = node.text
         end
 
-        xml.elements.each("//TranResponse/*") do |node|
-          if node.name.to_s == "Amount"
+        xml.elements.each('//TranResponse/*') do |node|
+          if node.name.to_s == 'Amount'
             node.elements.each do |amt|
               response[amt.name.underscore.to_sym] = amt.text
             end
@@ -293,12 +289,12 @@ module ActiveMerchant #:nodoc:
 
       def build_header
         {
-          "SOAPAction" => "http://www.mercurypay.com/CreditTransaction",
-          "Content-Type" => "text/xml; charset=utf-8"
+          'SOAPAction' => 'http://www.mercurypay.com/CreditTransaction',
+          'Content-Type' => 'text/xml; charset=utf-8'
         }
       end
 
-      SUCCESS_CODES = [ 'Approved', 'Success' ]
+      SUCCESS_CODES = %w[Approved Success]
 
       def commit(action, request)
         response = parse(action, ssl_post(endpoint_url, build_soap_request(request), build_header))
@@ -307,11 +303,11 @@ module ActiveMerchant #:nodoc:
         message = success ? 'Success' : message_from(response)
 
         Response.new(success, message, response,
-          :test => test?,
-          :authorization => authorization_from(response),
-          :avs_result => { :code => response[:avs_result] },
-          :cvv_result => response[:cvv_result],
-          :error_code => success ? nil : STANDARD_ERROR_CODE_MAPPING[response[:dsix_return_code]])
+          test: test?,
+          authorization: authorization_from(response),
+          avs_result: { code: response[:avs_result] },
+          cvv_result: response[:cvv_result],
+          error_code: success ? nil : STANDARD_ERROR_CODE_MAPPING[response[:dsix_return_code]])
       end
 
       def message_from(response)
@@ -319,7 +315,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorization_from(response)
-        dollars, cents = (response[:purchase] || "").split(".").collect{|e| e.to_i}
+        dollars, cents = (response[:purchase] || '').split('.').collect(&:to_i)
         dollars ||= 0
         cents ||= 0
         [
@@ -330,17 +326,17 @@ module ActiveMerchant #:nodoc:
           response[:process_data],
           response[:record_no],
           ((dollars * 100) + cents).to_s
-        ].join(";")
+        ].join(';')
       end
 
       def split_authorization(authorization)
-        invoice_no, ref_no, auth_code, acq_ref_data, process_data, record_no, amount = authorization.split(";")
+        invoice_no, ref_no, auth_code, acq_ref_data, process_data, record_no, amount = authorization.split(';')
         [invoice_no, ref_no, auth_code, acq_ref_data, process_data, record_no, amount]
       end
 
       ENVELOPE_NAMESPACES = {
         'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
-        'xmlns:soap' => "http://schemas.xmlsoap.org/soap/envelope/",
+        'xmlns:soap' => 'http://schemas.xmlsoap.org/soap/envelope/',
         'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance'
       }
 
@@ -349,7 +345,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def unescape_xml(escaped_xml)
-        escaped_xml.gsub(/\&gt;/,'>').gsub(/\&lt;/,'<')
+        escaped_xml.gsub(/\&gt;/, '>').gsub(/\&lt;/, '<')
       end
     end
   end

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

@@ -20,8 +20,8 @@ module ActiveMerchant #:nodoc:
 
       class_attribute :test_url, :live_url
 
-      self.test_url = "https://secure.metricsglobalgateway.com/gateway/transact.dll?testing=true"
-      self.live_url = "https://secure.metricsglobalgateway.com/gateway/transact.dll"
+      self.test_url = 'https://secure.metricsglobalgateway.com/gateway/transact.dll?testing=true'
+      self.live_url = 'https://secure.metricsglobalgateway.com/gateway/transact.dll'
 
       class_attribute :duplicate_window
 
@@ -31,12 +31,12 @@ module ActiveMerchant #:nodoc:
       AVS_RESULT_CODE, TRANSACTION_ID, CARD_CODE_RESPONSE_CODE  = 5, 6, 38
 
       self.supported_countries = ['US']
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+      self.supported_cardtypes = %i[visa master american_express discover diners_club jcb]
       self.homepage_url = 'http://www.metricsglobal.com'
       self.display_name = 'Metrics Global'
 
-      CARD_CODE_ERRORS = %w( N S )
-      AVS_ERRORS = %w( A E N R W Z )
+      CARD_CODE_ERRORS = %w(N S)
+      AVS_ERRORS = %w(A E N R W Z)
       AVS_REASON_CODES = %w(27 45)
 
       # Creates a new MetricsGlobalGateway
@@ -99,7 +99,7 @@ module ActiveMerchant #:nodoc:
       # * <tt>money</tt> -- The amount to be captured as an Integer value in cents.
       # * <tt>authorization</tt> -- The authorization returned from the previous authorize request.
       def capture(money, authorization, options = {})
-        post = {:trans_id => authorization}
+        post = { trans_id: authorization }
         add_customer_data(post, options)
         commit('PRIOR_AUTH_CAPTURE', money, post)
       end
@@ -110,7 +110,7 @@ module ActiveMerchant #:nodoc:
       #
       # * <tt>authorization</tt> - The authorization returned from the previous authorize request.
       def void(authorization, options = {})
-        post = {:trans_id => authorization}
+        post = { trans_id: authorization }
         add_duplicate_window(post)
         commit('VOID', nil, post)
       end
@@ -135,9 +135,8 @@ module ActiveMerchant #:nodoc:
       def refund(money, identification, options = {})
         requires!(options, :card_number)
 
-        post = { :trans_id => identification,
-                 :card_num => options[:card_number]
-               }
+        post = { trans_id: identification,
+                 card_num: options[:card_number] }
 
         post[:first_name] = options[:first_name] if options[:first_name]
         post[:last_name] = options[:last_name] if options[:last_name]
@@ -177,12 +176,11 @@ module ActiveMerchant #:nodoc:
         test_mode = test? || message =~ /TESTMODE/
 
         Response.new(success?(response), message, response,
-          :test => test_mode,
-          :authorization => response[:transaction_id],
-          :fraud_review => fraud_review?(response),
-          :avs_result => { :code => response[:avs_result_code] },
-          :cvv_result => response[:card_code]
-        )
+          test: test_mode,
+          authorization: response[:transaction_id],
+          fraud_review: fraud_review?(response),
+          avs_result: { code: response[:avs_result_code] },
+          cvv_result: response[:card_code])
       end
 
       def success?(response)
@@ -197,12 +195,12 @@ module ActiveMerchant #:nodoc:
         fields = split(body)
 
         results = {
-          :response_code => fields[RESPONSE_CODE].to_i,
-          :response_reason_code => fields[RESPONSE_REASON_CODE],
-          :response_reason_text => fields[RESPONSE_REASON_TEXT],
-          :avs_result_code => fields[AVS_RESULT_CODE],
-          :transaction_id => fields[TRANSACTION_ID],
-          :card_code => fields[CARD_CODE_RESPONSE_CODE]
+          response_code: fields[RESPONSE_CODE].to_i,
+          response_reason_code: fields[RESPONSE_REASON_CODE],
+          response_reason_text: fields[RESPONSE_REASON_TEXT],
+          avs_result_code: fields[AVS_RESULT_CODE],
+          transaction_id: fields[TRANSACTION_ID],
+          card_code: fields[CARD_CODE_RESPONSE_CODE]
         }
         results
       end
@@ -213,14 +211,14 @@ module ActiveMerchant #:nodoc:
         post[:version]        = API_VERSION
         post[:login]          = @options[:login]
         post[:tran_key]       = @options[:password]
-        post[:relay_response] = "FALSE"
+        post[:relay_response] = 'FALSE'
         post[:type]           = action
-        post[:delim_data]     = "TRUE"
-        post[:delim_char]     = ","
-        post[:encap_char]     = "$"
+        post[:delim_data]     = 'TRUE'
+        post[:delim_char]     = ','
+        post[:encap_char]     = '$'
         post[:solution_ID]    = application_id if application_id
 
-        request = post.merge(parameters).collect { |key, value| "x_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request = post.merge(parameters).collect { |key, value| "x_#{key}=#{CGI.escape(value.to_s)}" }.join('&')
         request
       end
 
@@ -243,21 +241,15 @@ module ActiveMerchant #:nodoc:
           post[:email_customer] = false
         end
 
-        if options.has_key? :customer
-          post[:cust_id] = options[:customer]
-        end
+        post[:cust_id] = options[:customer] if options.has_key? :customer
 
-        if options.has_key? :ip
-          post[:customer_ip] = options[:ip]
-        end
+        post[:customer_ip] = options[:ip] if options.has_key? :ip
       end
 
       # x_duplicate_window won't be sent by default, because sending it changes the response.
       # "If this field is present in the request with or without a value, an enhanced duplicate transaction response will be sent."
       def add_duplicate_window(post)
-        unless duplicate_window.nil?
-          post[:duplicate_window] = duplicate_window
-        end
+        post[:duplicate_window] = duplicate_window unless duplicate_window.nil?
       end
 
       def add_address(post, options)
@@ -268,7 +260,7 @@ module ActiveMerchant #:nodoc:
           post[:zip]     = address[:zip].to_s
           post[:city]    = address[:city].to_s
           post[:country] = address[:country].to_s
-          post[:state]   = address[:state].blank?  ? 'n/a' : address[:state]
+          post[:state]   = address[:state].blank? ? 'n/a' : address[:state]
         end
 
         if address = options[:shipping_address]
@@ -280,16 +272,14 @@ module ActiveMerchant #:nodoc:
           post[:ship_to_zip]     = address[:zip].to_s
           post[:ship_to_city]    = address[:city].to_s
           post[:ship_to_country] = address[:country].to_s
-          post[:ship_to_state]   = address[:state].blank?  ? 'n/a' : address[:state]
+          post[:ship_to_state]   = address[:state].blank? ? 'n/a' : address[:state]
         end
       end
 
       def message_from(results)
         if results[:response_code] == DECLINED
-          return CVVResult.messages[ results[:card_code] ] if CARD_CODE_ERRORS.include?(results[:card_code])
-          if AVS_REASON_CODES.include?(results[:response_reason_code]) && AVS_ERRORS.include?(results[:avs_result_code])
-            return AVSResult.messages[ results[:avs_result_code] ]
-          end
+          return CVVResult.messages[results[:card_code]] if CARD_CODE_ERRORS.include?(results[:card_code])
+          return AVSResult.messages[results[:avs_result_code]] if AVS_REASON_CODES.include?(results[:response_reason_code]) && AVS_ERRORS.include?(results[:avs_result_code])
         end
 
         (results[:response_reason_text] ? results[:response_reason_text].chomp('.') : '')