activemerchant 1.42.6 → 1.90.0

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

@@ -0,0 +1,417 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # For more information on the Authorize.Net Gateway please visit their {Integration Center}[http://developer.authorize.net/]
+    #
+    # The login and password are not the username and password you use to
+    # login to the Authorize.Net Merchant Interface. Instead, you will
+    # use the API Login ID as the login and Transaction Key as the
+    # password.
+    #
+    # ==== How to Get Your API Login ID and Transaction Key
+    #
+    # 1. Log into the Merchant Interface
+    # 2. Select Settings from the Main Menu
+    # 3. Click on API Login ID and Transaction Key in the Security section
+    # 4. Type in the answer to the secret question configured on setup
+    # 5. Click Submit
+    #
+    # ==== Automated Recurring Billing (ARB)
+    #
+    # Automated Recurring Billing (ARB) is an optional service for submitting and managing recurring, or subscription-based, transactions.
+    #
+    # To use recurring, update_recurring, cancel_recurring and status_recurring ARB must be enabled for your account.
+    #
+    # Information about ARB is available on the {Authorize.Net website}[http://www.authorize.net/solutions/merchantsolutions/merchantservices/automatedrecurringbilling/].
+    # Information about the ARB API is available at the {Authorize.Net Integration Center}[http://developer.authorize.net/]
+    class AuthorizeNetArbGateway < Gateway
+      API_VERSION = '3.1'
+
+      self.test_url = 'https://apitest.authorize.net/xml/v1/request.api'
+      self.live_url = 'https://api.authorize.net/xml/v1/request.api'
+
+      self.default_currency = 'USD'
+
+      self.supported_countries = ['US', 'CA', 'GB']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+      self.homepage_url = 'http://www.authorize.net/'
+      self.display_name = 'Authorize.Net'
+
+      AUTHORIZE_NET_ARB_NAMESPACE = 'AnetApi/xml/v1/schema/AnetApiSchema.xsd'
+
+      RECURRING_ACTIONS = {
+        :create => 'ARBCreateSubscription',
+        :update => 'ARBUpdateSubscription',
+        :cancel => 'ARBCancelSubscription',
+        :status => 'ARBGetSubscriptionStatus'
+      }
+
+      # Creates a new AuthorizeNetArbGateway
+      #
+      # The gateway requires that a valid login and password be passed
+      # in the +options+ hash.
+      #
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- The Authorize.Net API Login ID (REQUIRED)
+      # * <tt>:password</tt> -- The Authorize.Net Transaction Key. (REQUIRED)
+      # * <tt>:test</tt> -- +true+ or +false+. If true, perform transactions against the test server.
+      #   Otherwise, perform transactions against the production server.
+      def initialize(options = {})
+        ActiveMerchant.deprecated 'ARB functionality in ActiveMerchant is deprecated and will be removed in a future version. Please contact the ActiveMerchant maintainers if you have an interest in taking ownership of a separate gem that continues support for it.'
+        requires!(options, :login, :password)
+        super
+      end
+
+      # Create a recurring payment.
+      #
+      # This transaction creates a new Automated Recurring Billing (ARB) subscription. Your account must have ARB enabled.
+      #
+      # ==== Parameters
+      #
+      # * <tt>money</tt> -- The amount to be charged to the customer at each interval as an Integer value in cents.
+      # * <tt>creditcard</tt> -- The CreditCard details for the transaction.
+      # * <tt>options</tt> -- A hash of parameters.
+      #
+      # ==== Options
+      #
+      # * <tt>:interval</tt> -- A hash containing information about the interval of time between payments. Must
+      #   contain the keys <tt>:length</tt> and <tt>:unit</tt>. <tt>:unit</tt> can be either <tt>:months</tt> or <tt>:days</tt>.
+      #   If <tt>:unit</tt> is <tt>:months</tt> then <tt>:length</tt> must be an integer between 1 and 12 inclusive.
+      #   If <tt>:unit</tt> is <tt>:days</tt> then <tt>:length</tt> must be an integer between 7 and 365 inclusive.
+      #   For example, to charge the customer once every three months the hash would be
+      #   +:interval => { :unit => :months, :length => 3 }+ (REQUIRED)
+      # * <tt>:duration</tt> -- A hash containing keys for the <tt>:start_date</tt> the subscription begins (also the date the
+      #   initial billing occurs) and the total number of billing <tt>:occurrences</tt> or payments for the subscription. (REQUIRED)
+      def recurring(money, creditcard, options={})
+        requires!(options, :interval, :duration, :billing_address)
+        requires!(options[:interval], :length, [:unit, :days, :months])
+        requires!(options[:duration], :start_date, :occurrences)
+        requires!(options[:billing_address], :first_name, :last_name)
+
+        options[:credit_card] = creditcard
+        options[:amount] = money
+
+        request = build_recurring_request(:create, options)
+        recurring_commit(:create, request)
+      end
+
+      # Update a recurring payment's details.
+      #
+      # This transaction updates an existing Automated Recurring Billing (ARB) subscription. Your account must have ARB enabled
+      # and the subscription must have already been created previously by calling +recurring()+. The ability to change certain
+      # details about a recurring payment is dependent on transaction history and cannot be determined until after calling
+      # +update_recurring()+. See the ARB XML Guide for such conditions.
+      #
+      # ==== Parameters
+      #
+      # * <tt>options</tt> -- A hash of parameters.
+      #
+      # ==== Options
+      #
+      # * <tt>:subscription_id</tt> -- A string containing the <tt>:subscription_id</tt> of the recurring payment already in place
+      #   for a given credit card. (REQUIRED)
+      def update_recurring(options={})
+        requires!(options, :subscription_id)
+        request = build_recurring_request(:update, options)
+        recurring_commit(:update, request)
+      end
+
+      # Cancel a recurring payment.
+      #
+      # This transaction cancels an existing Automated Recurring Billing (ARB) subscription. Your account must have ARB enabled
+      # and the subscription must have already been created previously by calling recurring()
+      #
+      # ==== Parameters
+      #
+      # * <tt>subscription_id</tt> -- A string containing the +subscription_id+ of the recurring payment already in place
+      #   for a given credit card. (REQUIRED)
+      def cancel_recurring(subscription_id)
+        request = build_recurring_request(:cancel, :subscription_id => subscription_id)
+        recurring_commit(:cancel, request)
+      end
+
+      # Get Subscription Status of a recurring payment.
+      #
+      # This transaction gets the status of an existing Automated Recurring Billing (ARB) subscription. Your account must have ARB enabled.
+      #
+      # ==== Parameters
+      #
+      # * <tt>subscription_id</tt> -- A string containing the +subscription_id+ of the recurring payment already in place
+      #   for a given credit card. (REQUIRED)
+      def status_recurring(subscription_id)
+        request = build_recurring_request(:status, :subscription_id => subscription_id)
+        recurring_commit(:status, request)
+      end
+
+      private
+
+      # Builds recurring billing request
+      def build_recurring_request(action, options = {})
+        unless RECURRING_ACTIONS.include?(action)
+          raise StandardError, "Invalid Automated Recurring Billing Action: #{action}"
+        end
+
+        xml = Builder::XmlMarkup.new(:indent => 2)
+        xml.instruct!(:xml, :version => '1.0', :encoding => 'utf-8')
+        xml.tag!("#{RECURRING_ACTIONS[action]}Request", :xmlns => AUTHORIZE_NET_ARB_NAMESPACE) do
+          add_merchant_authentication(xml)
+          # Merchant-assigned reference ID for the request
+          xml.tag!('refId', options[:ref_id]) if options[:ref_id]
+          send("build_#{action}_subscription_request", xml, options)
+        end
+      end
+
+      # Contains the merchant’s payment gateway account authentication information
+      def add_merchant_authentication(xml)
+        xml.tag!('merchantAuthentication') do
+          xml.tag!('name', @options[:login])
+          xml.tag!('transactionKey', @options[:password])
+        end
+      end
+
+      # Builds body for ARBCreateSubscriptionRequest
+      def build_create_subscription_request(xml, options)
+        # Subscription
+        add_subscription(xml, options)
+
+        xml.target!
+      end
+
+      # Builds body for ARBUpdateSubscriptionRequest
+      def build_update_subscription_request(xml, options)
+        xml.tag!('subscriptionId', options[:subscription_id])
+        # Adds Subscription
+        add_subscription(xml, options)
+
+        xml.target!
+      end
+
+      # Builds body for ARBCancelSubscriptionRequest
+      def build_cancel_subscription_request(xml, options)
+        xml.tag!('subscriptionId', options[:subscription_id])
+
+        xml.target!
+      end
+
+      # Builds body for ARBGetSubscriptionStatusRequest
+      def build_status_subscription_request(xml, options)
+        xml.tag!('subscriptionId', options[:subscription_id])
+
+        xml.target!
+      end
+
+      # Adds subscription information
+      def add_subscription(xml, options)
+        xml.tag!('subscription') do
+          # Merchant-assigned name for the subscription (optional)
+          xml.tag!('name', options[:subscription_name]) if options[:subscription_name]
+          # Contains information about the payment schedule
+          add_payment_schedule(xml, options)
+          # The amount to be billed to the customer
+          # for each payment in the subscription
+          xml.tag!('amount', amount(options[:amount])) if options[:amount]
+          if trial = options[:trial]
+            # The amount to be charged for each payment during a trial period (conditional)
+            xml.tag!('trialAmount', amount(trial[:amount])) if trial[:amount]
+          end
+          # Contains either the customer’s credit card
+          # or bank account payment information
+          add_payment(xml, options)
+          # Contains order information (optional)
+          add_order(xml, options)
+          # Contains information about the customer
+          add_customer(xml, options)
+          # Contains the customer's billing address information
+          add_address(xml, 'billTo', options[:billing_address])
+          # Contains the customer's shipping address information (optional)
+          add_address(xml, 'shipTo', options[:shipping_address])
+        end
+      end
+
+      # Adds information about the interval of time between payments
+      def add_interval(xml, options)
+        interval = options[:interval]
+        return unless interval
+        xml.tag!('interval') do
+          # The measurement of time, in association with the Interval Unit,
+          # that is used to define the frequency of the billing occurrences
+          xml.tag!('length', interval[:length])
+          # The unit of time, in association with the Interval Length,
+          # between each billing occurrence
+          xml.tag!('unit', interval[:unit].to_s)
+        end
+      end
+
+      # Adds information about the subscription duration
+      def add_duration(xml, options)
+        duration = options[:duration]
+        return unless duration
+        # The date the subscription begins
+        # (also the date the initial billing occurs)
+        xml.tag!('startDate', duration[:start_date]) if duration[:start_date]
+        # Number of billing occurrences or payments for the subscription
+        xml.tag!('totalOccurrences', duration[:occurrences]) if duration[:occurrences]
+      end
+
+      def add_payment_schedule(xml, options)
+        return unless options[:interval] || options[:duration]
+        xml.tag!('paymentSchedule') do
+          # Contains information about the interval of time between payments
+          add_interval(xml, options)
+          add_duration(xml, options)
+          if trial = options[:trial]
+            # Number of billing occurrences or payments in the trial period (optional)
+            xml.tag!('trialOccurrences', trial[:occurrences]) if trial[:occurrences]
+          end
+        end
+      end
+
+      # Adds customer's credit card or bank account payment information
+      def add_payment(xml, options)
+        return unless options[:credit_card] || options[:bank_account]
+        xml.tag!('payment') do
+          # Contains the customer’s credit card information
+          add_credit_card(xml, options)
+          # Contains the customer’s bank account information
+          add_bank_account(xml, options)
+        end
+      end
+
+      # Adds customer’s credit card information
+      # Note: This element should only be included
+      # when the payment method is credit card.
+      def add_credit_card(xml, options)
+        credit_card = options[:credit_card]
+        return unless credit_card
+        xml.tag!('creditCard') do
+          # The credit card number used for payment of the subscription
+          xml.tag!('cardNumber', credit_card.number)
+          # The expiration date of the credit card used for the subscription
+          xml.tag!('expirationDate', expdate(credit_card))
+        end
+      end
+
+      # Adds customer’s bank account information
+      # Note: This element should only be included
+      # when the payment method is bank account.
+      def add_bank_account(xml, options)
+        bank_account = options[:bank_account]
+        return unless bank_account
+        xml.tag!('bankAccount') do
+          # The type of bank account used for payment of the subscription
+          xml.tag!('accountType', bank_account[:account_type])
+          # The routing number of the customer’s bank
+          xml.tag!('routingNumber', bank_account[:routing_number])
+          # The bank account number used for payment of the subscription
+          xml.tag!('accountNumber', bank_account[:account_number])
+          # The full name of the individual associated
+          # with the bank account number
+          xml.tag!('nameOfAccount', bank_account[:name_of_account])
+          # The full name of the individual associated
+          # with the bank account number (optional)
+          xml.tag!('bankName', bank_account[:bank_name]) if bank_account[:bank_name]
+          # The type of electronic check transaction used for the subscription
+          xml.tag!('echeckType', bank_account[:echeck_type])
+        end
+      end
+
+      # Adds order information (optional)
+      def add_order(xml, options)
+        order = options[:order]
+        return unless order
+        xml.tag!('order') do
+          # Merchant-assigned invoice number for the subscription (optional)
+          xml.tag!('invoiceNumber', order[:invoice_number])
+          # Description of the subscription (optional)
+          xml.tag!('description', order[:description])
+        end
+      end
+
+      # Adds information about the customer
+      def add_customer(xml, options)
+        customer = options[:customer]
+        return unless customer
+        xml.tag!('customer') do
+          xml.tag!('type', customer[:type]) if customer[:type]
+          xml.tag!('id', customer[:id]) if customer[:id]
+          xml.tag!('email', customer[:email]) if customer[:email]
+          xml.tag!('phoneNumber', customer[:phone_number]) if customer[:phone_number]
+          xml.tag!('faxNumber', customer[:fax_number]) if customer[:fax_number]
+          add_drivers_license(xml, options)
+          xml.tag!('taxId', customer[:tax_id]) if customer[:tax_id]
+        end
+      end
+
+      # Adds the customer's driver's license information (conditional)
+      def add_drivers_license(xml, options)
+        return unless customer = options[:customer]
+        return unless drivers_license = customer[:drivers_license]
+        xml.tag!('driversLicense') do
+          # The customer's driver's license number
+          xml.tag!('number', drivers_license[:number])
+          # The customer's driver's license state
+          xml.tag!('state', drivers_license[:state])
+          # The customer's driver's license date of birth
+          xml.tag!('dateOfBirth', drivers_license[:date_of_birth])
+        end
+      end
+
+      # Adds address information
+      def add_address(xml, container_name, address)
+        return if address.blank?
+        xml.tag!(container_name) do
+          xml.tag!('firstName', address[:first_name])
+          xml.tag!('lastName', address[:last_name])
+          xml.tag!('company', address[:company])
+          xml.tag!('address', address[:address1])
+          xml.tag!('city', address[:city])
+          xml.tag!('state', address[:state])
+          xml.tag!('zip', address[:zip])
+          xml.tag!('country', address[:country])
+        end
+      end
+
+      def expdate(credit_card)
+        sprintf('%04d-%02d', credit_card.year, credit_card.month)
+      end
+
+      def recurring_commit(action, request)
+        url = test? ? test_url : live_url
+        xml = ssl_post(url, request, 'Content-Type' => 'text/xml')
+
+        response = recurring_parse(action, xml)
+
+        message = response[:message] || response[:text]
+        test_mode = test? || message =~ /Test Mode/
+        success = response[:result_code] == 'Ok'
+
+        Response.new(success, message, response,
+          :test => test_mode,
+          :authorization => response[:subscription_id]
+        )
+      end
+
+      def recurring_parse(action, xml)
+        response = {}
+        xml = REXML::Document.new(xml)
+        root = REXML::XPath.first(xml, "//#{RECURRING_ACTIONS[action]}Response") ||
+               REXML::XPath.first(xml, '//ErrorResponse')
+        if root
+          root.elements.to_a.each do |node|
+            recurring_parse_element(response, node)
+          end
+        end
+
+        response
+      end
+
+      def recurring_parse_element(response, node)
+        if node.has_elements?
+          node.elements.each { |e| recurring_parse_element(response, e) }
+        else
+          response[node.name.underscore.to_sym] = node.text
+        end
+      end
+    end
+  end
+end

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

@@ -28,7 +28,7 @@ module ActiveMerchant #:nodoc:
     # 5. Click Submit
     class AuthorizeNetCimGateway < Gateway
       self.test_url = 'https://apitest.authorize.net/xml/v1/request.api'
-      self.live_url = 'https://api.authorize.net/xml/v1/request.api'
+      self.live_url = 'https://api2.authorize.net/xml/v1/request.api'
 
       AUTHORIZE_NET_CIM_NAMESPACE = 'AnetApi/xml/v1/schema/AnetApiSchema.xsd'
 
@@ -363,6 +363,10 @@ module ActiveMerchant #:nodoc:
       #     - :type = (:void, :refund, :prior_auth_capture) (NOT USED)
       #     - :type = (:auth_only, :capture_only, :auth_capture) (OPTIONAL)
       #
+      # * <tt>:recurring_billing</tt> -- The recurring billing status (OPTIONAL)
+      #     - :type = (:void, :refund, :prior_auth_capture) (NOT USED)
+      #     - :type = (:auth_only, :capture_only, :auth_capture) (OPTIONAL)
+      #
       # * <tt>:customer_shipping_address_id</tt> -- Payment gateway assigned ID associated with the customer shipping address (CONDITIONAL)
       #     - :type = (:void, :refund) (OPTIONAL)
       #     - :type = (:auth_only, :capture_only, :auth_capture) (NOT USED)
@@ -375,19 +379,19 @@ module ActiveMerchant #:nodoc:
         requires!(options, :transaction)
         requires!(options[:transaction], :type)
         case options[:transaction][:type]
-          when :void
-            requires!(options[:transaction], :trans_id)
-          when :refund
-            requires!(options[:transaction], :trans_id) &&
-              (
-                (options[:transaction][:customer_profile_id] && options[:transaction][:customer_payment_profile_id]) ||
-                options[:transaction][:credit_card_number_masked] ||
-                (options[:transaction][:bank_routing_number_masked] && options[:transaction][:bank_account_number_masked])
-              )
-          when :prior_auth_capture
-            requires!(options[:transaction], :amount, :trans_id)
-          else
-            requires!(options[:transaction], :amount, :customer_profile_id, :customer_payment_profile_id)
+        when :void
+          requires!(options[:transaction], :trans_id)
+        when :refund
+          requires!(options[:transaction], :trans_id) &&
+            (
+              (options[:transaction][:customer_profile_id] && options[:transaction][:customer_payment_profile_id]) ||
+              options[:transaction][:credit_card_number_masked] ||
+              (options[:transaction][:bank_routing_number_masked] && options[:transaction][:bank_account_number_masked])
+            )
+        when :prior_auth_capture
+          requires!(options[:transaction], :amount, :trans_id)
+        else
+          requires!(options[:transaction], :amount, :customer_profile_id, :customer_payment_profile_id)
         end
         request = build_request(:create_customer_profile_transaction, options)
         commit(:create_customer_profile_transaction, request)
@@ -570,6 +574,7 @@ module ActiveMerchant #:nodoc:
       def build_get_customer_payment_profile_request(xml, options)
         xml.tag!('customerProfileId', options[:customer_profile_id])
         xml.tag!('customerPaymentProfileId', options[:customer_payment_profile_id])
+        xml.tag!('unmaskExpirationDate', options[:unmask_expiration_date]) if options[:unmask_expiration_date]
         xml.target!
       end
 
@@ -609,10 +614,12 @@ module ActiveMerchant #:nodoc:
 
       def build_create_customer_profile_transaction_request(xml, options)
         options[:extra_options] ||= {}
-        options[:extra_options].merge!('x_test_request' => 'TRUE') if @options[:test_requests]
+        options[:extra_options]['x_delim_char'] = @options[:delimiter] if @options[:delimiter]
 
         add_transaction(xml, options[:transaction])
-        tag_unless_blank(xml, 'extraOptions', format_extra_options(options[:extra_options]))
+        xml.tag!('extraOptions') do
+          xml.cdata!(format_extra_options(options[:extra_options]))
+        end unless options[:extra_options].blank?
 
         xml.target!
       end
@@ -658,35 +665,40 @@ module ActiveMerchant #:nodoc:
           xml.tag!(CIM_TRANSACTION_TYPES[transaction[:type]]) do
             # The amount to be billed to the customer
             case transaction[:type]
-              when :void
-                tag_unless_blank(xml,'customerProfileId', transaction[:customer_profile_id])
-                tag_unless_blank(xml,'customerPaymentProfileId', transaction[:customer_payment_profile_id])
-                tag_unless_blank(xml,'customerShippingAddressId', transaction[:customer_shipping_address_id])
-                xml.tag!('transId', transaction[:trans_id])
-              when :refund
-                #TODO - add lineItems field
-                xml.tag!('amount', transaction[:amount])
-                tag_unless_blank(xml, 'customerProfileId', transaction[:customer_profile_id])
-                tag_unless_blank(xml, 'customerPaymentProfileId', transaction[:customer_payment_profile_id])
-                tag_unless_blank(xml, 'customerShippingAddressId', transaction[:customer_shipping_address_id])
-                tag_unless_blank(xml, 'creditCardNumberMasked', transaction[:credit_card_number_masked])
-                tag_unless_blank(xml, 'bankRoutingNumberMasked', transaction[:bank_routing_number_masked])
-                tag_unless_blank(xml, 'bankAccountNumberMasked', transaction[:bank_account_number_masked])
-                xml.tag!('transId', transaction[:trans_id])
-                add_tax(xml, transaction[:tax]) if transaction[:tax]
-                add_duty(xml, transaction[:duty]) if transaction[:duty]
-                add_shipping(xml, transaction[:shipping]) if transaction[:shipping]
-              when :prior_auth_capture
-                xml.tag!('amount', transaction[:amount])
-                xml.tag!('transId', transaction[:trans_id])
-              else
-                xml.tag!('amount', transaction[:amount])
-                xml.tag!('customerProfileId', transaction[:customer_profile_id])
-                xml.tag!('customerPaymentProfileId', transaction[:customer_payment_profile_id])
-                xml.tag!('approvalCode', transaction[:approval_code]) if transaction[:type] == :capture_only
+            when :void
+              tag_unless_blank(xml, 'customerProfileId', transaction[:customer_profile_id])
+              tag_unless_blank(xml, 'customerPaymentProfileId', transaction[:customer_payment_profile_id])
+              tag_unless_blank(xml, 'customerShippingAddressId', transaction[:customer_shipping_address_id])
+              xml.tag!('transId', transaction[:trans_id])
+            when :refund
+              xml.tag!('amount', transaction[:amount])
+              tag_unless_blank(xml, 'customerProfileId', transaction[:customer_profile_id])
+              tag_unless_blank(xml, 'customerPaymentProfileId', transaction[:customer_payment_profile_id])
+              tag_unless_blank(xml, 'customerShippingAddressId', transaction[:customer_shipping_address_id])
+              tag_unless_blank(xml, 'creditCardNumberMasked', transaction[:credit_card_number_masked])
+              tag_unless_blank(xml, 'bankRoutingNumberMasked', transaction[:bank_routing_number_masked])
+              tag_unless_blank(xml, 'bankAccountNumberMasked', transaction[:bank_account_number_masked])
+              add_order(xml, transaction[:order]) if transaction[:order].present?
+              xml.tag!('transId', transaction[:trans_id])
+              add_tax(xml, transaction[:tax]) if transaction[:tax]
+              add_duty(xml, transaction[:duty]) if transaction[:duty]
+              add_shipping(xml, transaction[:shipping]) if transaction[:shipping]
+            when :prior_auth_capture
+              xml.tag!('amount', transaction[:amount])
+              add_order(xml, transaction[:order]) if transaction[:order].present?
+              xml.tag!('transId', transaction[:trans_id])
+            else
+              xml.tag!('amount', transaction[:amount])
+              xml.tag!('customerProfileId', transaction[:customer_profile_id])
+              xml.tag!('customerPaymentProfileId', transaction[:customer_payment_profile_id])
+              xml.tag!('approvalCode', transaction[:approval_code]) if transaction[:type] == :capture_only
+              add_order(xml, transaction[:order]) if transaction[:order].present?
+
+            end
+            if [:auth_capture, :auth_only, :capture_only].include?(transaction[:type])
+              xml.tag!('recurringBilling', transaction[:recurring_billing]) if transaction.has_key?(:recurring_billing)
             end
-            add_order(xml, transaction[:order]) if transaction[:order].present?
-            unless [:void,:refund,:prior_auth_capture].include?(transaction[:type])
+            unless [:void, :refund, :prior_auth_capture].include?(transaction[:type])
               tag_unless_blank(xml, 'cardCode', transaction[:card_code])
             end
           end
@@ -787,7 +799,7 @@ module ActiveMerchant #:nodoc:
         return unless credit_card
         xml.tag!('creditCard') do
           # The credit card number used for payment of the subscription
-          xml.tag!('cardNumber', credit_card.number)
+          xml.tag!('cardNumber', full_or_masked_card_number(credit_card.number))
           # The expiration date of the credit card used for the subscription
           xml.tag!('expirationDate', expdate(credit_card))
           # Note that Authorize.net does not save CVV codes as part of the
@@ -841,20 +853,24 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, request)
         url = test? ? test_url : live_url
-        xml = ssl_post(url, request, "Content-Type" => "text/xml")
+        xml = ssl_post(url, request, 'Content-Type' => 'text/xml')
 
         response_params = parse(action, xml)
 
-        message = response_params['messages']['message']['text']
+        message_element= response_params['messages']['message']
+        first_error = message_element.is_a?(Array) ? message_element.first : message_element
+        message = first_error['text']
         test_mode = @options[:test_requests] || message =~ /Test Mode/
         success = response_params['messages']['result_code'] == 'Ok'
         response_params['direct_response'] = parse_direct_response(response_params['direct_response']) if response_params['direct_response']
         transaction_id = response_params['direct_response']['transaction_id'] if response_params['direct_response']
 
-        Response.new(success, message, response_params,
-          :test => test_mode,
-          :authorization => transaction_id || response_params['customer_profile_id'] || (response_params['profile'] ? response_params['profile']['customer_profile_id'] : nil)
-        )
+        response_options = {}
+        response_options[:test] = test_mode
+        response_options[:authorization] = transaction_id || response_params['customer_profile_id'] || (response_params['profile'] ? response_params['profile']['customer_profile_id'] : nil)
+        response_options[:error_code] = first_error['code'] unless success
+
+        Response.new(success, message, response_params, response_options)
       end
 
       def tag_unless_blank(xml, tag_name, data)
@@ -862,7 +878,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def format_extra_options(options)
-        options.map{ |k, v| "#{k}=#{v}" }.join('&') unless options.nil?
+        options&.map { |k, v| "#{k}=#{v}" }&.join('&')
       end
 
       def parse_direct_response(params)
@@ -925,7 +941,7 @@ module ActiveMerchant #:nodoc:
       def parse(action, xml)
         xml = REXML::Document.new(xml)
         root = REXML::XPath.first(xml, "//#{CIM_ACTIONS[action]}Response") ||
-               REXML::XPath.first(xml, "//ErrorResponse")
+               REXML::XPath.first(xml, '//ErrorResponse')
         if root
           response = parse_element(root)
         end
@@ -936,7 +952,7 @@ module ActiveMerchant #:nodoc:
       def parse_element(node)
         if node.has_elements?
           response = {}
-          node.elements.each{ |e|
+          node.elements.each { |e|
             key = e.name.underscore
             value = parse_element(e)
             if response.has_key?(key)
@@ -955,6 +971,10 @@ module ActiveMerchant #:nodoc:
 
         response
       end
+
+      def full_or_masked_card_number(card_number)
+        !card_number.nil? && card_number.length == 4 ? "XXXX#{card_number}" : card_number
+      end
     end
   end
 end