activemerchant 1.43.3 → 1.44.0

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

@@ -557,6 +557,7 @@ module ActiveMerchant #:nodoc:
           add_check(xml, payment_method_or_reference)
         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_purchase_data(xml, money, true, options)
           add_creditcard(xml, payment_method_or_reference)
         end

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

@@ -1,3 +1,5 @@
+require "active_support/core_ext/string/access"
+
 module ActiveMerchant
   module Billing
     class DataCashGateway < Gateway
@@ -138,7 +140,7 @@ module ActiveMerchant
       #   * <tt>:address</tt>:: billing address for card
       def credit(money, reference_or_credit_card, options = {})
         if reference_or_credit_card.is_a?(String)
-          deprecated CREDIT_DEPRECATION_MESSAGE
+          ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
           refund(money, reference_or_credit_card)
         else
           request = build_refund_request(money, reference_or_credit_card, options)

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

@@ -36,7 +36,7 @@ module ActiveMerchant #:nodoc:
 
       def credit(money, identification_or_credit_card, options = {})
         if identification_or_credit_card.is_a?(String)
-          deprecated CREDIT_DEPRECATION_MESSAGE
+          ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
           # Perform authorization reversal
           refund(money, identification_or_credit_card, options)
         else
@@ -54,7 +54,7 @@ module ActiveMerchant #:nodoc:
 
       def void(identification, options = {})
         requires!(options, :order_id)
-        original_transaction_id, original_transaction_amount = identification.split(";")
+        original_transaction_id, _ = identification.split(";")
         commit(:void_transaction, {:reference_number => format_reference_number(options[:order_id]), :transaction_id => original_transaction_id})
       end
 
@@ -81,7 +81,7 @@ module ActiveMerchant #:nodoc:
 
         requires!(options, :order_id)
 
-        post = {
+        {
           :reference_number => format_reference_number(options[:order_id]),
           :transaction_amount => amount(money),
           :original_transaction_amount => original_transaction_amount,
@@ -197,17 +197,6 @@ module ActiveMerchant #:nodoc:
         message.gsub(/[^\w]/, ' ').split.join(" ").capitalize
       end
 
-      # Make a ruby type out of the response string
-      def normalize(field)
-        case field
-        when "true"   then true
-        when "false"  then false
-        when ""       then nil
-        when "null"   then nil
-        else field
-        end
-      end
-
       def actions
         ACTIONS
       end

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

@@ -47,7 +47,9 @@ module ActiveMerchant #:nodoc:
         :refund => 'CCRETURN',
         :authorize => 'CCAUTHONLY',
         :capture => 'CCFORCE',
-        :void => 'CCVOID'
+        :void => 'CCDELETE',
+        :store => 'CCGETTOKEN',
+        :update => 'CCUPDATETOKEN',
       }
 
       # Initialize the Gateway
@@ -67,11 +69,15 @@ module ActiveMerchant #:nodoc:
       end
 
       # Make a purchase
-      def purchase(money, creditcard, options = {})
+      def purchase(money, payment_method, options = {})
         form = {}
         add_salestax(form, options)
         add_invoice(form, options)
-        add_creditcard(form, creditcard)
+        if payment_method.is_a?(String)
+          add_token(form, payment_method)
+        else
+          add_creditcard(form, payment_method)
+        end
         add_address(form, options)
         add_customer_data(form, options)
         add_test_mode(form, options)
@@ -166,8 +172,36 @@ module ActiveMerchant #:nodoc:
         commit(:credit, money, form)
       end
 
+      def verify(credit_card, options = {})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def store(creditcard, options = {})
+        form = {}
+        add_creditcard(form, creditcard)
+        add_address(form, options)
+        add_customer_data(form, options)
+        add_test_mode(form, options)
+        add_verification(form, options)
+        form[:add_token] = 'Y'
+        commit(:store, nil, form)
+      end
+
+      def update(token, creditcard, options = {})
+        form = {}
+        add_token(form, token)
+        add_creditcard(form, creditcard)
+        add_address(form, options)
+        add_customer_data(form, options)
+        add_test_mode(form, options)
+        commit(:update, nil, form)
+      end
 
       private
+
       def add_invoice(form,options)
         form[:invoice_number] = (options[:order_id] || options[:invoice]).to_s.slice(0, 10)
         form[:description] = options[:description].to_s.slice(0, 255)
@@ -197,6 +231,10 @@ module ActiveMerchant #:nodoc:
         form[:last_name] = creditcard.last_name.to_s.slice(0, 30)
       end
 
+      def add_token(form, token)
+        form[:token] = token
+      end
+
       def add_verification_value(form, creditcard)
         form[:cvv2cvc2] = creditcard.verification_value
         form[:cvv2cvc2_indicator] = '1'
@@ -211,12 +249,6 @@ module ActiveMerchant #:nodoc:
         form[:salestax] = options[:tax] if options[:tax].present?
       end
 
-      def expdate(creditcard)
-        year  = sprintf("%.4i", creditcard.year)
-        month = sprintf("%.2i", creditcard.month)
-        "#{month}#{year[2..3]}"
-      end
-
       def add_address(form,options)
         billing_address = options[:billing_address] || options[:address]
 
@@ -245,6 +277,10 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_verification(form, options)
+        form[:verify] = 'Y' if options[:verify]
+      end
+
       def parse_first_and_last_name(value)
         name = value.to_s.split(' ')
 

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

@@ -106,7 +106,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, identification, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, identification, options)
       end
 
@@ -268,7 +268,7 @@ module ActiveMerchant #:nodoc:
 
       # Limited to 20 digits max
       def format_order_number(number)
-        number.to_s.gsub(/[^\w_]/, '').rjust(4, "0")[0...20]
+        number.to_s.gsub(/[^\w]/, '').rjust(4, "0")[0...20]
       end
     end
   end

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

@@ -8,7 +8,7 @@ module ActiveMerchant #:nodoc:
       self.live_url = 'https://www.eway.com.au'
 
       self.money_format = :cents
-      self.supported_countries = ['AU', 'NZ', 'GB']
+      self.supported_countries = ['AU']
       self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
       self.homepage_url = 'http://www.eway.com.au/'
       self.display_name = 'eWAY'
@@ -136,17 +136,6 @@ module ActiveMerchant #:nodoc:
         MESSAGES[message[0,2]] || message
       end
 
-      # Make a ruby type out of the response string
-      def normalize(field)
-        case field
-        when "true"   then true
-        when "false"  then false
-        when ""       then nil
-        when "null"   then nil
-        else field
-        end
-      end
-
       def purchase_url(cvn)
         suffix = test? ? 'xmltest/testpage.asp' : 'xmlpayment.asp'
         gateway_part = cvn ? 'gateway_cvn' : 'gateway'

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

@@ -150,7 +150,7 @@ module ActiveMerchant #:nodoc:
       def parse(body)
         reply = {}
         xml = REXML::Document.new(body)
-         if root = REXML::XPath.first(xml, "//soap:Fault") then
+        if root = REXML::XPath.first(xml, "//soap:Fault") then
            reply=parse_fault(root)
         else
           if root = REXML::XPath.first(xml, '//ProcessPaymentResponse/ewayResponse') then

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

@@ -1,5 +1,4 @@
-require "nokogiri"
-require "cgi"
+require 'json'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
@@ -8,10 +7,10 @@ module ActiveMerchant #:nodoc:
       self.live_url = "https://api.ewaypayments.com/"
 
       self.money_format = :cents
-      self.supported_countries = ["AU"]
+      self.supported_countries = ['AU', 'NZ', 'GB']
       self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
       self.homepage_url = "http://www.eway.com.au/"
-      self.display_name = "eWAY Rapid 3.0"
+      self.display_name = "eWAY Rapid 3.1"
       self.default_currency = "AUD"
 
       def initialize(options = {})
@@ -19,203 +18,240 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      # Public: Run a purchase transaction. Treats the Rapid 3.0 transparent
-      # redirect as an API endpoint in order to conform to the standard
-      # ActiveMerchant #purchase API.
+      # Public: Run a purchase transaction.
       #
-      # amount  - The monetary amount of the transaction in cents.
-      # options - A standard ActiveMerchant options hash:
-      #           :order_id         - A merchant-supplied identifier for the
-      #                               transaction (optional).
-      #           :description      - A merchant-supplied description of the
-      #                               transaction (optional).
-      #           :currency         - Three letter currency code for the
-      #                               transaction (default: "AUD")
-      #           :billing_address  - Standard ActiveMerchant address hash
-      #                               (optional).
-      #           :shipping_address - Standard ActiveMerchant address hash
-      #                               (optional).
-      #           :ip               - The ip of the consumer initiating the
-      #                               transaction (optional).
-      #           :application_id   - A string identifying the application
-      #                               submitting the transaction
-      #                               (default: "https://github.com/Shopify/active_merchant")
+      # amount         - The monetary amount of the transaction in cents.
+      # payment_method - The payment method or authorization token returned from store.
+      # options        - A standard ActiveMerchant options hash:
+      #                  :transaction_type - One of: Purchase (default), MOTO
+      #                                      or Recurring.  For stored card payments (aka - TokenPayments),
+      #                                      this must be either MOTO or Recurring.
+      #                  :order_id         - A merchant-supplied identifier for the
+      #                                      transaction (optional).
+      #                  :description      - A merchant-supplied description of the
+      #                                      transaction (optional).
+      #                  :currency         - Three letter currency code for the
+      #                                      transaction (default: "AUD")
+      #                  :billing_address  - Standard ActiveMerchant address hash
+      #                                      (optional).
+      #                  :shipping_address - Standard ActiveMerchant address hash
+      #                                      (optional).
+      #                  :ip               - The ip of the consumer initiating the
+      #                                      transaction (optional).
+      #                  :application_id   - A string identifying the application
+      #                                      submitting the transaction
+      #                                      (default: "https://github.com/Shopify/active_merchant")
       #
-      # Returns an ActiveMerchant::Billing::Response object
+      # Returns an ActiveMerchant::Billing::Response object where authorization is the Transaction ID on success
       def purchase(amount, payment_method, options={})
-        MultiResponse.new.tap do |r|
-          # Rather than follow the redirect, we detect the 302 and capture the
-          # token out of the Location header in the run_purchase step. But we
-          # still need a placeholder url to pass to eWay, and that is what
-          # example.com is used for here.
-          r.process{setup_purchase(amount, options.merge(:redirect_url => "http://example.com/"))}
-          r.process{run_purchase(r.authorization, payment_method, r.params["formactionurl"])}
-          r.process{status(r.authorization)}
-        end
+        params = {}
+        add_metadata(params, options)
+        add_invoice(params, amount, options)
+        add_customer_data(params, options)
+        add_credit_card(params, payment_method, options)
+        commit(url_for('Transaction'), params)
       end
 
-      # Public: Acquire the token necessary to run a transparent redirect.
-      #
-      # amount  - The monetary amount of the transaction in cents.
-      # options - A supplemented ActiveMerchant options hash:
-      #           :redirect_url     - The url to return the customer to after
-      #                               the transparent redirect is completed
-      #                               (required).
-      #           :order_id         - A merchant-supplied identifier for the
-      #                               transaction (optional).
-      #           :description      - A merchant-supplied description of the
-      #                               transaction (optional).
-      #           :currency         - Three letter currency code for the
-      #                               transaction (default: "AUD")
-      #           :billing_address  - Standard ActiveMerchant address hash
-      #                               (optional).
-      #           :shipping_address - Standard ActiveMerchant address hash
-      #                               (optional).
-      #           :ip               - The ip of the consumer initiating the
-      #                               transaction (optional).
-      #           :application_id   - A string identifying the application
-      #                               submitting the transaction
-      #                               (default: "https://github.com/Shopify/active_merchant")
-      #
-      # Returns an EwayRapidResponse object, which conforms to the
-      # ActiveMerchant::Billing::Response API, but also exposes #form_url.
-      def setup_purchase(amount, options={})
-        requires!(options, :redirect_url)
-        request = build_xml_request("CreateAccessCodeRequest") do |doc|
-          add_metadata(doc, options)
-          add_invoice(doc, amount, options)
-          add_customer_data(doc, options)
-        end
+      def authorize(amount, payment_method, options={})
+        params = {}
+        add_metadata(params, options)
+        add_invoice(params, amount, options)
+        add_customer_data(params, options)
+        add_credit_card(params, payment_method, options)
+        commit(url_for('Authorisation'), params)
+      end
+
+      def capture(amount, identification, options = {})
+        params = {}
+        add_metadata(params, options)
+        add_invoice(params, amount, options)
+        add_reference(params, identification)
+        commit(url_for("CapturePayment"), params)
+      end
 
-        commit(url_for("CreateAccessCode"), request)
+      def void(identification, options = {})
+        params = {}
+        add_reference(params, identification)
+        commit(url_for("CancelAuthorisation"), params)
       end
 
-      # Public: Retrieve the status of a transaction.
+      # Public: Refund a transaction.
       #
-      # identification - The Eway Rapid 3.0 access code for the transaction
-      #                  (returned as the response.authorization by
-      #                  #setup_purchase).
+      # amount         - The monetary amount of the transaction in cents
+      # identification - The transaction id which is returned in the
+      #                  authorization of the successful purchase transaction
+      # options        - A standard ActiveMerchant options hash:
+      #                  :order_id         - A merchant-supplied identifier for the
+      #                                      transaction (optional).
+      #                  :description      - A merchant-supplied description of the
+      #                                      transaction (optional).
+      #                  :currency         - Three letter currency code for the
+      #                                      transaction (default: "AUD")
+      #                  :billing_address  - Standard ActiveMerchant address hash
+      #                                      (optional).
+      #                  :shipping_address - Standard ActiveMerchant address hash
+      #                                      (optional).
+      #                  :ip               - The ip of the consumer initiating the
+      #                                      transaction (optional).
+      #                  :application_id   - A string identifying the application
+      #                                      submitting the transaction
+      #                                      (default: "https://github.com/Shopify/active_merchant")
       #
-      # Returns an EwayRapidResponse object.
-      def status(identification)
-        request = build_xml_request("GetAccessCodeResultRequest") do |doc|
-          doc.AccessCode identification
-        end
-        commit(url_for("GetAccessCodeResult"), request)
+      # Returns an ActiveMerchant::Billing::Response object
+      def refund(amount, identification, options = {})
+        params = {}
+        add_metadata(params, options)
+        add_invoice(params, amount, options, "Refund")
+        add_reference(params["Refund"], identification)
+        add_customer_data(params, options)
+        commit(url_for("Transaction/#{identification}/Refund"), params)
       end
 
       # Public: Store card details and return a valid token
       #
-      # options - A supplemented ActiveMerchant options hash:
-      #           :order_id         - A merchant-supplied identifier for the
-      #                               transaction (optional).
-      #           :billing_address  - Standard ActiveMerchant address hash
-      #                               (required).
-      #           :ip               - The ip of the consumer initiating the
-      #                               transaction (optional).
-      #           :application_id   - A string identifying the application
-      #                               submitting the transaction
-      #                               (default: "https://github.com/Shopify/active_merchant")
+      # payment_method - The payment method or nil if :customer_token is provided
+      # options        - A supplemented ActiveMerchant options hash:
+      #                  :order_id         - A merchant-supplied identifier for the
+      #                                      transaction (optional).
+      #                  :description      - A merchant-supplied description of the
+      #                                      transaction (optional).
+      #                  :billing_address  - Standard ActiveMerchant address hash
+      #                                      (required).
+      #                  :ip               - The ip of the consumer initiating the
+      #                                      transaction (optional).
+      #                  :application_id   - A string identifying the application
+      #                                      submitting the transaction
+      #                                      (default: "https://github.com/Shopify/active_merchant")
+      #
+      # Returns an ActiveMerchant::Billing::Response object where the authorization is the customer_token on success
       def store(payment_method, options = {})
         requires!(options, :billing_address)
-        purchase(0, payment_method, options.merge(:request_method => "CreateTokenCustomer"))
+        params = {}
+        add_metadata(params, options)
+        add_invoice(params, 0, options)
+        add_customer_data(params, options)
+        add_credit_card(params, payment_method, options)
+        params['Method'] = 'CreateTokenCustomer'
+        commit(url_for("Transaction"), params)
       end
 
-      private
+      # Public: Update a customer's data
+      #
+      # customer_token - The customer token returned in the authorization of
+      #                  a successful store transaction.
+      # payment_method - The payment method or nil if :customer_token is provided
+      # options        - A supplemented ActiveMerchant options hash:
+      #                  :order_id         - A merchant-supplied identifier for the
+      #                                      transaction (optional).
+      #                  :description      - A merchant-supplied description of the
+      #                                      transaction (optional).
+      #                  :billing_address  - Standard ActiveMerchant address hash
+      #                                      (optional).
+      #                  :ip               - The ip of the consumer initiating the
+      #                                      transaction (optional).
+      #                  :application_id   - A string identifying the application
+      #                                      submitting the transaction
+      #                                      (default: "https://github.com/Shopify/active_merchant")
+      #
+      # Returns an ActiveMerchant::Billing::Response object where the authorization is the customer_token on success
+      def update(customer_token, payment_method, options = {})
+        params = {}
+        add_metadata(params, options)
+        add_invoice(params, 0, options)
+        add_customer_data(params, options)
+        add_credit_card(params, payment_method, options)
+        add_customer_token(params, customer_token)
+        params['Method'] = 'UpdateTokenCustomer'
+        commit(url_for("Transaction"), params)
+      end
 
-      def run_purchase(identification, payment_method, endpoint)
-        post = {
-          "accesscode" => identification
-        }
-        add_credit_card(post, payment_method)
+      private
 
-        commit_form(endpoint, build_form_request(post), :identification => identification)
+      def add_metadata(params, options)
+        params['RedirectUrl'] = options[:redirect_url] || 'http://example.com'
+        params['CustomerIP'] = options[:ip] if options[:ip]
+        params['TransactionType'] = options[:transaction_type] || 'Purchase'
+        params['DeviceID'] = options[:application_id] || application_id
       end
 
-      def add_metadata(doc, options)
-        doc.RedirectUrl(options[:redirect_url])
-        doc.CustomerIP options[:ip] if options[:ip]
-        doc.Method options[:request_method] || "ProcessPayment"
-        doc.DeviceID(options[:application_id] || application_id)
+      def add_invoice(params, money, options, key = "Payment")
+        currency_code = options[:currency] || currency(money)
+        params[key] = {
+          'TotalAmount' => localized_amount(money, currency_code),
+          'InvoiceReference' => truncate(options[:order_id]),
+          'InvoiceDescription' => truncate(options[:description], 64),
+          'CurrencyCode' => currency_code,
+        }
       end
 
-      def add_invoice(doc, money, options)
-        doc.Payment do
-          currency_code = options[:currency] || currency(money)
-          doc.TotalAmount localized_amount(money, currency_code)
-          doc.InvoiceReference options[:order_id]
-          doc.InvoiceDescription options[:description]
-          doc.CurrencyCode currency_code
-        end
+      def add_reference(params, reference)
+        params['TransactionID'] = reference
       end
 
-      def add_customer_data(doc, options)
-        doc.Customer do
-          add_address(doc, (options[:billing_address] || options[:address]), {:email => options[:email]})
-        end
-        doc.ShippingAddress do
-          add_address(doc, options[:shipping_address], {:skip_company => true})
-        end
+      def add_customer_data(params, options)
+        params['Customer'] ||= {}
+        add_address(params['Customer'], (options[:billing_address] || options[:address]), {:email => options[:email]})
+        params['ShippingAddress'] = {}
+        add_address(params['ShippingAddress'], options[:shipping_address], {:skip_company => true})
       end
 
-      def add_address(doc, address, options={})
+      def add_address(params, address, options={})
         return unless address
-        if name = address[:name]
-          parts = name.split(/\s+/)
-          doc.FirstName parts.shift if parts.size > 1
-          doc.LastName parts.join(" ")
-        end
-        doc.Title address[:title]
-        doc.CompanyName address[:company] unless options[:skip_company]
-        doc.Street1 address[:address1]
-        doc.Street2 address[:address2]
-        doc.City address[:city]
-        doc.State address[:state]
-        doc.PostalCode address[:zip]
-        doc.Country address[:country].to_s.downcase
-        doc.Phone address[:phone]
-        doc.Fax address[:fax]
-        doc.Email options[:email]
-      end
 
-      def add_credit_card(post, credit_card)
-        post["cardname"] = credit_card.name
-        post["cardnumber"] = credit_card.number
-        post["cardexpirymonth"] = credit_card.month
-        post["cardexpiryyear"] = credit_card.year
-        post["cardcvn"] = credit_card.verification_value
+        if address[:name]
+          parts = address[:name].split(/\s+/)
+          params['FirstName'] = parts.shift if parts.size > 1
+          params['LastName'] = parts.join(" ")
+        end
+        params['Title'] = address[:title]
+        params['CompanyName'] = address[:company] unless options[:skip_company]
+        params['Street1'] = truncate(address[:address1])
+        params['Street2'] = truncate(address[:address2])
+        params['City'] = truncate(address[:city])
+        params['State'] = address[:state]
+        params['PostalCode'] = address[:zip]
+        params['Country'] = address[:country].to_s.downcase
+        params['Phone'] = address[:phone]
+        params['Fax'] = address[:fax]
+        params['Email'] = options[:email]
       end
 
-      def build_xml_request(root)
-        builder = Nokogiri::XML::Builder.new
-        builder.__send__(root) do |doc|
-          yield(doc)
+      def add_credit_card(params, credit_card, options)
+        return unless credit_card
+        params['Customer'] ||= {}
+        if credit_card.respond_to? :number
+          params['Method'] = 'ProcessPayment'
+          card_details = params['Customer']['CardDetails'] = {}
+          card_details['Name'] = truncate(credit_card.name)
+          card_details['Number'] = credit_card.number
+          card_details['ExpiryMonth'] = "%02d" % (credit_card.month || 0)
+          card_details['ExpiryYear'] = "%02d" % (credit_card.year || 0)
+          card_details['CVN'] = credit_card.verification_value
+        else
+          params['Method'] = 'TokenPayment'
+          add_customer_token(params, credit_card)
         end
-        builder.to_xml
       end
 
-      def build_form_request(post)
-        request = []
-        post.each do |key, value|
-          request << "EWAY_#{key.upcase}=#{CGI.escape(value.to_s)}"
-        end
-        request.join("&")
+      def add_customer_token(params, token)
+        params['Customer'] ||= {}
+        params['Customer']['TokenCustomerID'] = token
       end
 
       def url_for(action)
-        (test? ? test_url : live_url) + action + ".xml"
+        (test? ? test_url : live_url) + action
       end
 
-      def commit(url, request, form_post=false)
+      def commit(url, params)
         headers = {
           "Authorization" => ("Basic " + Base64.strict_encode64(@options[:login].to_s + ":" + @options[:password].to_s).chomp),
-          "Content-Type" => "text/xml"
+          "Content-Type" => "application/json"
         }
-
+        request = params.to_json
         raw = parse(ssl_post(url, request, headers))
 
         succeeded = success?(raw)
-        EwayRapidResponse.new(
+        ActiveMerchant::Billing::Response.new(
           succeeded,
           message_from(succeeded, raw),
           raw,
@@ -225,56 +261,32 @@ module ActiveMerchant #:nodoc:
           :cvv_result => cvv_result_from(raw)
         )
       rescue ActiveMerchant::ResponseError => e
-        return EwayRapidResponse.new(false, e.response.message, {:status_code => e.response.code}, :test => test?)
-      end
-
-      def commit_form(url, request, parameters)
-        http_response = raw_ssl_request(:post, url, request)
-
-        success = (http_response.code.to_s == "302")
-        message = (success ? "Succeeded" : http_response.body)
-        authorization = parameters[:identification] if success
-
-        Response.new(success, message, {:location => http_response["Location"]}, :authorization => authorization, :test => test?)
+        return ActiveMerchant::Billing::Response.new(false, e.response.message, {:status_code => e.response.code}, :test => test?)
       end
 
-      def parse(xml)
-        response = {}
-
-        doc = Nokogiri::XML(xml)
-        doc.root.xpath("*").each do |node|
-          if (node.elements.size == 0)
-            response[node.name.downcase.to_sym] = node.text
-          else
-            node.elements.each do |childnode|
-              name = "#{node.name.downcase}_#{childnode.name.downcase}"
-              response[name.to_sym] = childnode.text
-            end
-          end
-        end unless doc.root.nil?
-
-        response
+      def parse(data)
+        JSON.parse(data)
       end
 
       def success?(response)
-        if response[:errors]
-          false
-        elsif response[:responsecode] == "00"
+        if response['ResponseCode'] == "00"
           true
-        elsif response[:transactionstatus]
-          (response[:transactionstatus] == "true")
+        elsif response['TransactionStatus']
+          (response['TransactionStatus'] == true)
+        elsif response["Succeeded"]
+          (response["Succeeded"] == true)
         else
-          true
+          false
         end
       end
 
       def message_from(succeeded, response)
-        if response[:errors]
-          (MESSAGES[response[:errors]] || response[:errors])
-        elsif response[:responsecode]
-          ActiveMerchant::Billing::EwayGateway::MESSAGES[response[:responsecode]]
-        elsif response[:responsemessage]
-          (MESSAGES[response[:responsemessage]] || response[:responsemessage])
+        if response['Errors']
+          (MESSAGES[response['Errors']] || response['Errors'])
+        elsif response['Responsecode']
+          ActiveMerchant::Billing::EwayGateway::MESSAGES[response['ResponseCode']]
+        elsif response['ResponseMessage']
+          (MESSAGES[response['ResponseMessage']] || response['ResponseMessage'])
         elsif succeeded
           "Succeeded"
         else
@@ -283,11 +295,14 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorization_from(response)
-        response[:accesscode]
+        # Note: TransactionID is always null for store requests, but TokenCustomerID is also sent back for purchase from
+        # stored card transactions so we give precendence to TransactionID
+        response['TransactionID'] || response['Customer']['TokenCustomerID']
       end
 
       def avs_result_from(response)
-        code = case response[:verification_address]
+        verification = response['Verification'] || {}
+        code = case verification['Address']
         when "Valid"
           "M"
         when "Invalid"
@@ -299,7 +314,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def cvv_result_from(response)
-        case response[:verification_cvn]
+        verification = response['Verification'] || {}
+        case verification['CVN']
         when "Valid"
           "M"
         when "Invalid"
@@ -309,16 +325,30 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      class EwayRapidResponse < ActiveMerchant::Billing::Response
-        def form_url
-          params["formactionurl"]
-        end
+      def truncate(value, max_size = 50)
+        return nil unless value
+        value.to_s[0, max_size]
       end
 
       MESSAGES = {
+        'A2000' => 'Transaction Approved Successful',
+        'A2008' => 'Honour With Identification Successful',
+        'A2010' => 'Approved For Partial Amount Successful',
+        'A2011' => 'Approved, VIP Successful',
+        'A2016' => 'Approved, Update Track 3 Successful',
+        'S5000' => 'System Error',
+        'S5085' => 'Started 3dSecure',
+        'S5086' => 'Routed 3dSecure',
+        'S5087' => 'Completed 3dSecure',
+        'S5088' => 'PayPal Transaction Created',
+        'S5099' => 'Incomplete (Access Code in progress/incomplete)',
+        'S5010' => 'Unknown error returned by gateway',
         'V6000' => 'Validation error',
         'V6001' => 'Invalid CustomerIP',
         'V6002' => 'Invalid DeviceID',
+        'V6003' => 'Invalid Request PartnerID',
+        'V6004' => 'Invalid Request Method',
+        'V6010' => 'Invalid TransactionType, account not certified for eCome only MOTO or Recurring available',
         'V6011' => 'Invalid Payment TotalAmount',
         'V6012' => 'Invalid Payment InvoiceDescription',
         'V6013' => 'Invalid Payment InvoiceNumber',
@@ -385,7 +415,8 @@ module ActiveMerchant #:nodoc:
         'V6107' => 'Invalid EWAY_ACCESSCODE',
         'V6108' => 'Invalid CustomerHostAddress',
         'V6109' => 'Invalid UserAgent',
-        'V6110' => 'Invalid EWAY_CARDNUMBER'
+        'V6110' => 'Invalid EWAY_CARDNUMBER',
+        'V6111' => 'Unauthorised API Access, Account Not PCI Certified'
       }
     end
   end