activemerchant 1.46.0 → 1.47.0

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

@@ -0,0 +1,20 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class Flo2cashSimpleGateway < Flo2cashGateway
+      self.display_name = 'Flo2Cash Simple'
+
+      def purchase(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit("ProcessPurchase", post)
+      end
+
+      # Flo2Cash's "simple mode" does not support auth/capture
+      undef_method :authorize
+      undef_method :capture
+    end
+  end
+end

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

@@ -157,7 +157,7 @@ module ActiveMerchant #:nodoc:
       def add_auth_purchase_params(doc, money, payment_method, options)
         doc.orderId(truncated(options[:order_id]))
         doc.amount(money)
-        add_order_source(doc, payment_method)
+        add_order_source(doc, payment_method, options)
         add_billing_address(doc, payment_method, options)
         add_shipping_address(doc, payment_method, options)
         add_payment_method(doc, payment_method)
@@ -225,8 +225,10 @@ module ActiveMerchant #:nodoc:
         doc.phone(address[:phone]) unless address[:phone].blank?
       end
 
-      def add_order_source(doc, payment_method)
-        if payment_method.respond_to?(:track_data) && payment_method.track_data.present?
+      def add_order_source(doc, payment_method, options)
+        if options[:order_source]
+          doc.orderSource(options[:order_source])
+        elsif payment_method.respond_to?(:track_data) && payment_method.track_data.present?
           doc.orderSource('retail')
         else
           doc.orderSource('ecommerce')

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

@@ -220,12 +220,18 @@ module ActiveMerchant #:nodoc:
       end
 
       def response_object(response)
+        avs_response_code = response[:AVSResultCode]
+        avs_response_code = 'S' if avs_response_code == "Unsupported"
+
+        cvv_result_code = response[:CSCResultCode]
+        cvv_result_code = 'P' if cvv_result_code == "Unsupported"
+
         Response.new(success?(response), response[:Message], response,
           :test => test?,
           :authorization => response[:TransactionNo],
           :fraud_review => fraud_review?(response),
-          :avs_result => { :code => response[:AVSResultCode] },
-          :cvv_result => response[:CSCResultCode]
+          :avs_result => { :code => avs_response_code },
+          :cvv_result => cvv_result_code
         )
       end
 

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

@@ -178,7 +178,7 @@ module ActiveMerchant #:nodoc:
         action = 'settletx'
 
         options.merge!(:money => money, :authorization => authorization)
-        commit_capture(action, authorization, build_request(action, options))
+        commit(action, build_request(action, options), authorization)
       end
 
       def refund(money, authorization, options={})
@@ -199,19 +199,16 @@ module ActiveMerchant #:nodoc:
         xml.instruct!
 
         xml.tag! 'protocol', :ver => API_VERSION, :pgid => (test? ? TEST_ID : @options[:login]), :pwd => @options[:password] do |protocol|
+          money         = options.delete(:money)
+          authorization = options.delete(:authorization)
+          creditcard    = options.delete(:creditcard)
           case action
-            when 'authtx'
-              money       = options.delete(:money)
-              creditcard  = options.delete(:creditcard)
-              build_authorization(protocol, money, creditcard, options)
-            when 'settletx'
-              money           = options.delete(:money)
-              authorization   = options.delete(:authorization)
-              build_capture(protocol, money, authorization, options)
-            when 'refundtx'
-              money           = options.delete(:money)
-              authorization   = options.delete(:authorization)
-              build_refund(protocol, money, authorization, options)
+          when 'authtx'
+            build_authorization(protocol, money, creditcard, options)
+          when 'settletx'
+            build_capture(protocol, money, authorization, options)
+          when 'refundtx'
+            build_refund(protocol, money, authorization, options)
           else
             raise "no action specified for build_request"
           end
@@ -229,7 +226,9 @@ module ActiveMerchant #:nodoc:
           :budp  => 0,
           :amt   => amount(money),
           :cur   => (options[:currency] || currency(money)),
-          :cvv   => creditcard.verification_value
+          :cvv   => creditcard.verification_value,
+          :email => options[:email],
+          :ip    => options[:ip]
         }
       end
 
@@ -262,19 +261,11 @@ module ActiveMerchant #:nodoc:
         hash
       end
 
-      def commit(action, request)
+      def commit(action, request, authorization = nil)
         response = parse(action, ssl_post(self.live_url, request))
         Response.new(successful?(response), message_from(response), response,
           :test           => test?,
-          :authorization  => response[:tid]
-        )
-      end
-
-      def commit_capture(action, authorization, request)
-        response = parse(action, ssl_post(self.live_url, request))
-        Response.new(successful?(response), message_from(response), response,
-          :test           => test?,
-          :authorization  => authorization
+          :authorization  => authorization ? authorization : response[:tid]
         )
       end
 
@@ -283,5 +274,4 @@ module ActiveMerchant #:nodoc:
       end
     end
   end
-end
-
+end

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

@@ -44,6 +44,10 @@ module ActiveMerchant #:nodoc:
         commit(build_reference_request(:credit, money, reference, options), options)
       end
 
+      def verify(payment, options={})
+        authorize(0, payment, options)
+      end
+
       # Adds or modifies a recurring Payflow profile.  See the Payflow Pro Recurring Billing Guide for more details:
       # https://www.paypal.com/en_US/pdf/PayflowPro_RecurringBilling_Guide.pdf
       #

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

@@ -85,7 +85,7 @@ module ActiveMerchant #:nodoc:
           :test => (parsed['mode'] == 'test'),
         }
 
-        succeeded = (parsed['data'] == []) || (parsed['data']['response_code'] == 20000)
+        succeeded = (parsed['data'] == []) || (parsed['data']['response_code'].to_i == 20000)
         Response.new(succeeded, response_message(parsed), parsed, options)
       end
 
@@ -230,7 +230,7 @@ module ActiveMerchant #:nodoc:
         return parsed_response["error"] if parsed_response["error"]
         return "Transaction approved." if (parsed_response['data'] == [])
 
-        code = parsed_response["data"]["response_code"]
+        code = parsed_response["data"]["response_code"].to_i
         RESPONSE_CODES[code] || code.to_s
       end
 

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

@@ -152,8 +152,6 @@ module ActiveMerchant #:nodoc:
           body = parse(raw_response)
         rescue ResponseError => e
           body = parse(e.response.body)
-        rescue JSON::ParserError
-          return unparsable_response(raw_response)
         end
 
         if body["response"]
@@ -161,6 +159,9 @@ module ActiveMerchant #:nodoc:
         elsif body["error"]
           error_response(body)
         end
+
+      rescue JSON::ParserError
+        return unparsable_response(raw_response)
       end
 
       def success_response(body)

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

@@ -19,7 +19,7 @@ module ActiveMerchant #:nodoc:
                            currency autocapture cardnumber expirationdate
                            cvd cardtypelock testmode),
 
-          :capture   => %w(protocol msgtype merchant amount transaction),
+          :capture   => %w(protocol msgtype merchant amount finalize transaction),
 
           :cancel    => %w(protocol msgtype merchant transaction),
 
@@ -44,7 +44,7 @@ module ActiveMerchant #:nodoc:
                            fraud_http_accept_encoding fraud_http_accept_charset
                            fraud_http_referer fraud_http_user_agent apikey),
 
-          :capture   => %w(protocol msgtype merchant amount transaction apikey),
+          :capture   => %w(protocol msgtype merchant amount finalize transaction apikey),
 
           :cancel    => %w(protocol msgtype merchant transaction apikey),
 
@@ -72,7 +72,7 @@ module ActiveMerchant #:nodoc:
                            fraud_http_accept_encoding fraud_http_accept_charset
                            fraud_http_referer fraud_http_user_agent apikey),
 
-          :capture   => %w(protocol msgtype merchant amount transaction apikey),
+          :capture   => %w(protocol msgtype merchant amount finalize transaction apikey),
 
           :cancel    => %w(protocol msgtype merchant transaction apikey),
 
@@ -100,7 +100,7 @@ module ActiveMerchant #:nodoc:
                            fraud_http_accept_encoding fraud_http_accept_charset
                            fraud_http_referer fraud_http_user_agent apikey),
 
-          :capture   => %w(protocol msgtype merchant amount transaction
+          :capture   => %w(protocol msgtype merchant amount finalize transaction
                            apikey),
 
           :cancel    => %w(protocol msgtype merchant transaction apikey),
@@ -129,7 +129,7 @@ module ActiveMerchant #:nodoc:
                            fraud_http_accept_encoding fraud_http_accept_charset
                            fraud_http_referer fraud_http_user_agent apikey),
 
-          :capture   => %w(protocol msgtype merchant amount transaction
+          :capture   => %w(protocol msgtype merchant amount finalize transaction
                            apikey),
 
           :cancel    => %w(protocol msgtype merchant transaction apikey),
@@ -196,6 +196,7 @@ module ActiveMerchant #:nodoc:
       def capture(money, authorization, options = {})
         post = {}
 
+        add_finalize(post, options)
         add_reference(post, authorization)
         add_amount_without_currency(post, money)
         commit(:capture, post)
@@ -300,6 +301,10 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_finalize(post, options)
+        post[:finalize] = options[:finalize] ? '1' : '0'
+      end
+
       def commit(action, params)
         response = parse(ssl_post(self.live_url, post_data(action, params)))
 

data/lib/active_merchant/billing/network_tokenization_credit_card.rb

@@ -0,0 +1,16 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class NetworkTokenizationCreditCard < CreditCard
+      # A +NetworkTokenizationCreditCard+ object represents a tokenized credit card 
+      # using the EMV Network Tokenization specification, http://www.emvco.com/specifications.aspx?id=263.
+      #
+      # It includes all fields of the +CreditCard+ class with additional fields for 
+      # verification data that must be given to gateways through existing fields (3DS / EMV).
+      #
+      # The only tested usage of this at the moment is with an Apple Pay decrypted PKPaymentToken, 
+      # https://developer.apple.com/library/ios/documentation/PassKit/Reference/PaymentTokenJSON/PaymentTokenJSON.html 
+
+      attr_accessor :payment_cryptogram, :eci, :transaction_id
+    end
+  end
+end

data/lib/active_merchant/errors.rb

@@ -3,6 +3,12 @@ module ActiveMerchant #:nodoc:
   end
 
   class ConnectionError < ActiveMerchantError # :nodoc:
+    attr_reader :triggering_exception
+
+    def initialize(message, triggering_exception)
+      super(message)
+      @triggering_exception = triggering_exception
+    end
   end
 
   class RetriableConnectionError < ConnectionError # :nodoc:

data/lib/active_merchant/network_connection_retries.rb

@@ -21,14 +21,14 @@ module ActiveMerchant
         begin
           yield
         rescue Errno::ECONNREFUSED => e
-          raise ActiveMerchant::RetriableConnectionError, "The remote server refused the connection"
+          raise ActiveMerchant::RetriableConnectionError.new("The remote server refused the connection", e)
         rescue OpenSSL::X509::CertificateError => e
           NetworkConnectionRetries.log(options[:logger], :error, e.message, options[:tag])
           raise ActiveMerchant::ClientCertificateError, "The remote server did not accept the provided SSL certificate"
         rescue Zlib::BufError => e
           raise ActiveMerchant::InvalidResponseError, "The remote server replied with an invalid response"
         rescue *connection_errors.keys => e
-          raise ActiveMerchant::ConnectionError, derived_error_message(connection_errors, e.class)
+          raise ActiveMerchant::ConnectionError.new(derived_error_message(connection_errors, e.class), e)
         end
       end
     end
@@ -50,7 +50,7 @@ module ActiveMerchant
 
         log_with_retry_details(options[:logger], initial_retries-retries, Time.now.to_f - request_start, e.message, options[:tag])
         retry unless retries.zero?
-        raise ActiveMerchant::ConnectionError, e.message
+        raise ActiveMerchant::ConnectionError.new(e.message, e)
       rescue ActiveMerchant::ConnectionError, ActiveMerchant::InvalidResponseError => e
         retries -= 1
         log_with_retry_details(options[:logger], initial_retries-retries, Time.now.to_f - request_start, e.message, options[:tag])

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = "1.46.0"
+  VERSION = "1.47.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activemerchant
 version: !ruby/object:Gem::Version
-  version: 1.46.0
+  version: 1.47.0
 platform: ruby
 authors:
 - Tobias Luetke
@@ -30,7 +30,7 @@ cert_chain:
   fl3hbtVFTqbOlwL9vy1fudXcolIE/ZTcxQ+er07ZFZdKCXayR9PPs64heamfn0fp
   TConQSX2BnZdhIEYW+cKzEC/bLc=
   -----END CERTIFICATE-----
-date: 2015-01-21 00:00:00.000000000 Z
+date: 2015-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -142,20 +142,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
-- !ruby/object:Gem::Dependency
-  name: rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.14
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.14
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -244,6 +230,8 @@ files:
 - lib/active_merchant/billing/gateways/first_giving.rb
 - lib/active_merchant/billing/gateways/first_pay.rb
 - lib/active_merchant/billing/gateways/firstdata_e4.rb
+- lib/active_merchant/billing/gateways/flo2cash.rb
+- lib/active_merchant/billing/gateways/flo2cash_simple.rb
 - lib/active_merchant/billing/gateways/garanti.rb
 - lib/active_merchant/billing/gateways/global_transport.rb
 - lib/active_merchant/billing/gateways/hdfc.rb
@@ -352,13 +340,13 @@ files:
 - lib/active_merchant/billing/gateways/usa_epay_transaction.rb
 - lib/active_merchant/billing/gateways/verifi.rb
 - lib/active_merchant/billing/gateways/viaklix.rb
-- lib/active_merchant/billing/gateways/vindicia.rb
 - lib/active_merchant/billing/gateways/webpay.rb
 - lib/active_merchant/billing/gateways/wepay.rb
 - lib/active_merchant/billing/gateways/wirecard.rb
 - lib/active_merchant/billing/gateways/worldpay.rb
 - lib/active_merchant/billing/gateways/worldpay_us.rb
 - lib/active_merchant/billing/model.rb
+- lib/active_merchant/billing/network_tokenization_credit_card.rb
 - lib/active_merchant/billing/payment_token.rb
 - lib/active_merchant/billing/rails.rb
 - lib/active_merchant/billing/response.rb

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

@@ -1,385 +0,0 @@
-require 'i18n/core_ext/string/interpolate'
-
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-
-    # For more information on the Vindicia Gateway please visit their {website}[http://vindicia.com/]
-    #
-    # The login and password are not the username and password you use to
-    # login to the Vindicia Merchant Portal.
-    #
-    # ==== Recurring Billing
-    #
-    # AutoBills are an feature of Vindicia's API that allows for creating and managing subscriptions.
-    #
-    # For more information about Vindicia's API and various other services visit their {Resource Center}[http://www.vindicia.com/resources/index.html]
-    class VindiciaGateway < Gateway
-      self.supported_countries = %w{US CA GB AU MX BR DE KR CN HK}
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
-      self.homepage_url = 'http://www.vindicia.com/'
-      self.display_name = 'Vindicia'
-
-      class_attribute :test_url, :live_url
-
-      self.test_url = "https://soap.prodtest.sj.vindicia.com/soap.pl"
-      self.live_url = "http://soap.vindicia.com/soap.pl"
-
-      # Creates a new VindiciaGateway
-      #
-      # The gateway requires that a valid login and password be passed
-      # in the +options+ hash.
-      #
-      # ==== Options
-      #
-      # * <tt>:login</tt> -- Vindicia SOAP login (REQUIRED)
-      # * <tt>:password</tt> -- Vindicia SOAP password (REQUIRED)
-      # * <tt>:api_version</tt> -- Vindicia API Version - defaults to 3.6 (OPTIONAL)
-      # * <tt>:account_id</tt> -- Account Id which all transactions will be run against. (REQUIRED)
-      # * <tt>:transaction_prefix</tt> -- Prefix to order id for one-time transactions - defaults to 'X' (OPTIONAL
-      # * <tt>:min_chargeback_probability</tt> -- Minimum score for chargebacks - defaults to 65 (OPTIONAL)
-      # * <tt>:cvn_success</tt> -- Array of valid CVN Check return values - defaults to [M, P] (OPTIONAL)
-      # * <tt>:avs_success</tt> -- Array of valid AVS Check return values - defaults to [X, Y, A, W, Z] (OPTIONAL)
-      def initialize(options = {})
-        requires!(options, :login, :password, :account_id)
-        super
-
-        @account_id = options[:account_id]
-
-        @transaction_prefix = options[:transaction_prefix] || "X"
-
-        @min_chargeback_probability = options[:min_chargeback_probability] || 65
-        @cvn_success = options[:cvn_success] || %w{M P}
-        @avs_success = options[:avs_success] || %w{X Y A W Z}
-
-        @allowed_authorization_statuses = %w{Authorized}
-      end
-
-      # Perform a purchase, which is essentially an authorization and capture in a single operation.
-      #
-      # ==== Parameters
-      #
-      # * <tt>money</tt> -- The amount to be purchased as an Integer value in cents.
-      # * <tt>creditcard</tt> -- The CreditCard details for the transaction.
-      # * <tt>options</tt> -- A hash of optional parameters.
-      def purchase(money, creditcard, options = {})
-        response = authorize(money, creditcard, options)
-        return response if !response.success? || response.fraud_review?
-
-        capture(money, response.authorization, options)
-      end
-
-      # Performs an authorization, which reserves the funds on the customer's credit card, but does not
-      # charge the card.
-      #
-      # ==== Parameters
-      #
-      # * <tt>money</tt> -- The amount to be authorized as an Integer value in cents.
-      # * <tt>creditcard</tt> -- The CreditCard details for the transaction.
-      # * <tt>options</tt> -- A hash of optional parameters.
-      def authorize(money, creditcard, options = {})
-        vindicia_transaction = authorize_transaction(money, creditcard, options)
-        response = check_transaction(vindicia_transaction)
-
-        # if this response is under fraud review because of our AVS/CVV checks void the transaction
-        if !response.success? && response.fraud_review? && !response.authorization.blank?
-          void_response = void([vindicia_transaction[:transaction][:merchantTransactionId]], options)
-          if void_response.success?
-            return response
-          else
-            return void_response
-          end
-        end
-
-        response
-      end
-
-      # Captures the funds from an authorized transaction.
-      #
-      # ==== Parameters
-      #
-      # * <tt>money</tt> -- The amount to be captured as an Integer value in cents.
-      # * <tt>identification</tt> -- The authorization returned from the previous authorize request.
-      def capture(money, identification, options = {})
-        response = post(:capture) do |xml|
-          add_hash(xml, transactions: [{ merchantTransactionId: identification }])
-        end
-
-        if response[:return][:returnCode] != '200' || response[:qtyFail].to_i > 0
-          return fail(response)
-        end
-
-        success(response, identification)
-      end
-
-      # Void a previous transaction
-      #
-      # ==== Parameters
-      #
-      # * <tt>identification</tt> - The authorization returned from the previous authorize request.
-      # * <tt>options</tt> - Extra options (currently only :ip used)
-      def void(identification, options = {})
-        response = post(:cancel) do |xml|
-          add_hash(xml, transactions: [{
-            account: {merchantAccountId: @account_id},
-            merchantTransactionId: identification,
-            sourceIp: options[:ip]
-          }])
-        end
-
-        if response[:return][:returnCode] == '200' && response[:qtyFail].to_i == 0
-          success(response, identification)
-        else
-          fail(response)
-        end
-      end
-
-      # Perform a recurring billing, which is essentially a purchase and autobill setup in a single operation.
-      #
-      # ==== Parameters
-      #
-      # * <tt>money</tt> -- The amount to be purchased as an Integer value in cents.
-      # * <tt>creditcard</tt> -- The CreditCard details for the transaction.
-      # * <tt>options</tt> -- A hash of parameters.
-      #
-      # ==== Options
-      #
-      # * <tt>:product_sku</tt> -- The subscription product's sku
-      # * <tt>:autobill_prefix</tt> -- Prefix to order id for subscriptions - defaults to 'A' (OPTIONAL)
-      def recurring(money, creditcard, options={})
-        ActiveMerchant.deprecated RECURRING_DEPRECATION_MESSAGE
-
-        options[:recurring] = true
-        @autobill_prefix = options[:autobill_prefix] || "A"
-
-        response = authorize(money, creditcard, options)
-        return response if !response.success? || response.fraud_review?
-
-        capture_resp = capture(money, response.authorization, options)
-        return capture_resp if !response.success?
-
-        # Setting up a recurring AutoBill requires an associated product
-        requires!(options, :product_sku)
-        autobill_response = check_subscription(authorize_subscription(options.merge(:product_sku => options[:product_sku])))
-
-        if autobill_response.success?
-          autobill_response
-        else
-          # If the AutoBill fails to set-up, void the transaction and return it as the response
-          void_response = void(capture_resp.authorization, options)
-          if void_response.success?
-            return autobill_response
-          else
-            return void_response
-          end
-        end
-      end
-
-      private
-
-      def add_hash(xml, hash)
-        hash.each do |k,v|
-          add_element(xml, k, v)
-        end
-      end
-
-      def add_array(xml, elem, val)
-        val.each do |v|
-          add_element(xml, elem, v)
-        end
-      end
-
-      def add_element(xml, elem, val)
-        if val.is_a?(Hash)
-          xml.tag!(elem.to_s.camelize(:lower)) do |env|
-            add_hash(env, val)
-          end
-        elsif val.is_a?(Array)
-          add_array(xml, elem, val)
-        else
-          xml.tag!(elem.to_s.camelize(:lower), val.to_s)
-        end
-      end
-
-      def post(action, kind="Transaction")
-        xml = Builder::XmlMarkup.new
-        xml.instruct!(:xml, :encoding => "UTF-8")
-        xml.env :Envelope,
-          "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema",
-          "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
-          "xmlns:tns" => "http://soap.vindicia.com/v3_6/#{kind}",
-          "xmlns:env" => "http://schemas.xmlsoap.org/soap/envelope/" do
-
-          xml.env :Body do
-            xml.tns action.to_sym do
-              xml.auth do
-                xml.tag! :login, @options[:login]
-                xml.tag! :password, @options[:password]
-                xml.tag! :version, "3.6"
-              end
-
-              yield(xml)
-            end
-          end
-        end
-
-        url = (test? ? self.test_url : self.live_url)
-        parse(ssl_post(url, xml.target!, "Content-Type" => "text/xml"))
-      end
-
-      def parse(response)
-        # Vindicia always returns in the form of request_type_response => { actual_response }
-        Hash.from_xml(response)["Envelope"]["Body"].values.first.with_indifferent_access
-      end
-
-      def check_transaction(vindicia_transaction)
-        if vindicia_transaction[:return][:returnCode] == '200'
-          status_log = vindicia_transaction[:transaction][:statusLog].first
-          if status_log[:creditCardStatus]
-            avs = status_log[:creditCardStatus][:avsCode]
-            cvn = status_log[:creditCardStatus][:cvnCode]
-          end
-
-          if @allowed_authorization_statuses.include?(status_log[:status]) &&
-            check_cvn(cvn) && check_avs(avs)
-
-            success(vindicia_transaction,
-                    vindicia_transaction[:transaction][:merchantTransactionId],
-                    avs, cvn)
-          else
-            # If the transaction is authorized, but it didn't pass our AVS/CVV checks send the authorization along so
-            # that is gets voided. Otherwise, send no authorization.
-            fail(vindicia_transaction, avs, cvn, false,
-                 @allowed_authorization_statuses.include?(status_log[:status]) ? vindicia_transaction[:transaction][:merchantTransactionId] : "")
-          end
-        else
-          # 406 = Chargeback risk score is higher than minChargebackProbability, transaction not authorized.
-          fail(vindicia_transaction, nil, nil, vindicia_transaction[:return][:return_code] == '406')
-        end
-      end
-
-      def authorize_transaction(money, creditcard, options)
-        parameters = {
-          :amount => amount(money),
-          :currency => options[:currency] || currency(money)
-        }
-
-        add_account_data(parameters, options)
-        add_customer_data(parameters, options)
-        add_payment_source(parameters, creditcard, options)
-
-        post(:auth) do |xml|
-          add_hash(xml, transaction: parameters, minChargebackProbability: @min_chargeback_probability)
-        end
-      end
-
-      def add_account_data(parameters, options)
-        parameters[:account] = { :merchantAccountId => @account_id }
-        parameters[:sourceIp] = options[:ip] if options[:ip]
-      end
-
-      def add_customer_data(parameters, options)
-        parameters[:merchantTransactionId] = transaction_id(options[:order_id])
-        parameters[:shippingAddress] = convert_am_address_to_vindicia(options[:shipping_address])
-
-        # Transaction items must be provided for tax purposes
-        requires!(options, :line_items)
-        parameters[:transactionItems] = options[:line_items]
-
-        if options[:recurring]
-          parameters[:nameValues] = [{:name => 'merchantAutoBillIdentifier', :value => autobill_id(options[:order_id])}]
-        end
-      end
-
-      def add_payment_source(parameters, creditcard, options)
-        parameters[:sourcePaymentMethod] = {
-          :type => 'CreditCard',
-          :creditCard => { :account => creditcard.number, :expirationDate => "%4d%02d" % [creditcard.year, creditcard.month] },
-          :accountHolderName => creditcard.name,
-          :nameValues => [{ :name => 'CVN', :value => creditcard.verification_value }],
-          :billingAddress => convert_am_address_to_vindicia(options[:billing_address] || options[:address]),
-          :customerSpecifiedType => creditcard.brand.capitalize,
-          :active => !!options[:recurring]
-        }
-      end
-
-      def authorize_subscription(options)
-        parameters = {}
-
-        add_account_data(parameters, options)
-        add_subscription_information(parameters, options)
-
-        post(:update, "AutoBill") do |xml|
-          add_hash(xml, autobill: parameters, validatePaymentMethod: false, minChargebackProbability: 100)
-        end
-      end
-
-      def check_subscription(vindicia_transaction)
-        if vindicia_transaction[:return][:returnCode] == '200'
-          if vindicia_transaction[:autobill] && vindicia_transaction[:autobill][:status] == "Active"
-            success(vindicia_transaction,
-                    vindicia_transaction[:autobill][:merchantAutoBillId])
-          else
-            fail(vindicia_transaction)
-          end
-        else
-          fail(vindicia_transaction)
-        end
-      end
-
-      def add_subscription_information(parameters, options)
-        requires!(options, :product_sku)
-
-        if options[:shipping_address]
-          parameters[:account][:shipping_address] = options[:shipping_address]
-        end
-
-        parameters[:merchantAutoBillId] = autobill_id(options[:order_id])
-        parameters[:product] = { :merchantProductId => options[:product_sku] }
-      end
-
-      def check_avs(avs)
-        avs.blank? || @avs_success.include?(avs)
-      end
-
-      def check_cvn(cvn)
-        cvn.blank? || @cvn_success.include?(cvn)
-      end
-
-      def success(response, authorization, avs_code = nil, cvn_code = nil)
-        ActiveMerchant::Billing::Response.new(true, response[:return][:returnString], response,
-                                              { :fraud_review => false, :authorization => authorization, :test => test?,
-                                                :avs_result => { :code => avs_code }, :cvv_result => cvn_code })
-      end
-
-      def fail(response, avs_code = nil, cvn_code = nil, fraud_review = false, authorization = "")
-        ActiveMerchant::Billing::Response.new(false, response[:return][:returnString], response,
-                                              { :fraud_review => fraud_review || !authorization.blank?,
-                                                :authorization => authorization, :test => test?,
-                                                :avs_result => { :code => avs_code }, :cvv_result => cvn_code })
-
-      end
-
-      def autobill_id(order_id)
-        "#{@autobill_prefix}#{order_id}"
-      end
-
-      def transaction_id(order_id)
-        "#{@transaction_prefix}#{order_id}"
-      end
-
-      # Converts valid ActiveMerchant address hash to proper Vindicia format
-      def convert_am_address_to_vindicia(address)
-        return if address.nil?
-
-        convs = { :address1 => :addr1, :address2 => :addr2,
-          :state => :district, :zip => :postalCode }
-
-        vindicia_address = {}
-        address.each do |key, val|
-          vindicia_address[convs[key] || key] = val
-        end
-        vindicia_address
-      end
-    end
-  end
-end