activemerchant 1.0.3 → 1.1.0

data/CHANGELOG

@@ -1,5 +1,23 @@
 # CHANGELOG
 # ---
+# * Mark 1.1.0 release 
+#
+# * Add unique_id option to PayPal mass payments [Haig]
+#
+# * Fix expiry date in USA ePay [cody]
+#
+# * Fix PayPal Payments Pro UK with Switch & Solo cards [cody]
+#
+# * Add reauthorization to PaypalGateway and PaypalExpressGateway [dorrenchen]
+#
+# * Update DataCash tests and format merchant reference number to meet DataCash's requirements [MoneySpyder, cody]
+#
+# * Add Datacash gateway [MoneySpyder, cody]
+#
+# * VERIFY_PEER on all SSL requests [cody]
+#
+# * Add support for 2Checkout [cody] 
+#
 # * Add support for PayPal mass payments to the PaypalGateway and the PaypalExpressGateway [Brandon Keepers]
 #
 # * Add a credit method to Authorize.net [cody]

data/lib/active_merchant.rb

@@ -48,6 +48,8 @@ require 'active_merchant/lib/requires_parameters'
 require 'active_merchant/lib/country'
 
 # CreditCard Utility class. 
+require 'active_merchant/billing/credit_card_methods'
+require 'active_merchant/billing/credit_card_formatting'
 require 'active_merchant/billing/credit_card'
 
 require 'active_merchant/billing/base'

data/lib/active_merchant/billing/credit_card.rb

@@ -1,13 +1,13 @@
 require 'time'
-require 'delegate'
 require 'date'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-  
     # This credit card object can be used as a stand alone object. It acts just like a active record object
     # but doesn't support the .save method as its not backed by a database.
     class CreditCard
+      include CreditCardMethods
+      
       cattr_accessor :require_verification_value
       self.require_verification_value = false
       
@@ -17,47 +17,11 @@ module ActiveMerchant #:nodoc:
         
       include Validateable
 
-      class ExpiryMonth < DelegateClass(Fixnum)#:nodoc:
-        def to_s(format = :default) #:nodoc:
-          case format
-          when :default
-            __getobj__.to_s
-          when :two_digit
-            sprintf("%.2i", self)[-2..-1]
-          else
-            super
-          end  
-        end
-
-        def valid? #:nodoc:
-          (1..12).include?(self)
-        end
-      end
-
-      class ExpiryYear < DelegateClass(Fixnum)#:nodoc:
-        def to_s(format = :default) #:nodoc:
-          case format
-          when :default
-            __getobj__.to_s
-          when :two_digit
-            sprintf("%.2i", self)[-2..-1]
-          when :four_digit
-            sprintf("%.4i", self)
-          else
-            super
-          end  
-        end
-
-        def valid? #:nodoc:
-          (Time.now.year..Time.now.year + 20).include?(self)
-        end
-      end
-
       class ExpiryDate #:nodoc:
         attr_reader :month, :year
         def initialize(month, year)
-          @month = ExpiryMonth.new(month)
-          @year = ExpiryYear.new(year)
+          @month = month
+          @year = year
         end
 
         def expired? #:nodoc:
@@ -78,6 +42,9 @@ module ActiveMerchant #:nodoc:
 
       # required
       attr_accessor :number, :month, :year, :type, :first_name, :last_name
+      
+      # required for Switch / Solo
+      attr_accessor :start_month, :start_year, :issue_number
 
       # Optional verification_value (CVV, CVV2 etc)
       #
@@ -93,23 +60,31 @@ module ActiveMerchant #:nodoc:
       end
 
       def validate
-        @errors.add "year", "expired"                             if expired?
-             
-        @errors.add "first_name", "cannot be empty"               if @first_name.blank?
-        @errors.add "last_name", "cannot be empty"                if @last_name.blank?
-        @errors.add "month", "cannot be empty"                    unless month.valid?
-        @errors.add "year", "cannot be empty"                     unless year.valid?
+        errors.add "year", "expired"                             if expired?
+            
+        errors.add "first_name", "cannot be empty"               if @first_name.blank?
+        errors.add "last_name", "cannot be empty"                if @last_name.blank?
+        errors.add "month", "cannot be empty"                    unless valid_month?(@month)
+        errors.add "year", "cannot be empty"                     unless valid_expiry_year?(@year)
 
         # Bogus card is pretty much for testing purposes. Lets just skip these extra tests if its used
         
         return if type == 'bogus'
 
-        @errors.add "number", "is not a valid credit card number" unless CreditCard.valid_number?(number)                     
-        @errors.add "type", "is invalid"                         unless CreditCard.card_companies.keys.include?(type)
-        @errors.add "type", "is not the correct card type"        unless CreditCard.type?(number) == type
+        errors.add "number", "is not a valid credit card number" unless CreditCard.valid_number?(number)                     
+        errors.add "type", "is invalid"                          unless CreditCard.card_companies.keys.include?(type)
+        errors.add "type", "is not the correct card type"        unless CreditCard.type?(number) == type
         
         if CreditCard.requires_verification_value?
-          @errors.add "verification_value", "is required" unless verification_value?
+          errors.add "verification_value", "is required" unless verification_value?
+        end
+        
+        if [ 'switch', 'solo' ].include?(type)
+          unless valid_month?(@start_month) && valid_start_year?(@start_year) || valid_issue_number?(@issue_number)
+            errors.add "start_month", "is invalid"                    unless valid_month?(@start_month)
+            errors.add "start_year", "is invalid"                     unless valid_start_year?(@start_year)
+            errors.add "issue_number", "cannot be empty"              unless valid_issue_number?(@issue_number)
+          end
         end
       end  
       
@@ -137,61 +112,6 @@ module ActiveMerchant #:nodoc:
         !@verification_value.blank?
       end
 
-      # Regular expressions for the known card companies
-      # == Known card types
-      #	 Card Type                         Prefix                           Length
-      #  --------------------------------------------------------------------------
-      #	 master                            51-55                            16
-      #	 visa                              4                                13, 16
-      #	 american_express                  34, 37                           15
-      #	 diners_club                       300-305, 36, 38                  14
-      #	 discover                          6011                             16
-      #	 jcb                               3                                16
-      #	 jcb                               2131, 1800                       15
-      #	 switch                            various                          16,18,19
-      #	 solo                              63, 6767                         16,18,19
-      def self.card_companies
-        { 
-          'visa' =>  /^4\d{12}(\d{3})?$/,
-          'master' =>  /^5[1-5]\d{14}$/,
-          'discover' =>  /^6011\d{12}$/,
-          'american_express' =>  /^3[47]\d{13}$/,
-          'diners_club' =>  /^3(0[0-5]|[68]\d)\d{11}$/,
-          'jcb' =>  /^(3\d{4}|2131|1800)\d{11}$/,
-          'switch' =>  [/^49(03(0[2-9]|3[5-9])|11(0[1-2]|7[4-9]|8[1-2])|36[0-9]{2})\d{10}(\d{2,3})?$/, /^564182\d{10}(\d{2,3})?$/, /^6(3(33[0-4][0-9])|759[0-9]{2})\d{10}(\d{2,3})?$/],
-          'solo' =>  /^6(3(34[5-9][0-9])|767[0-9]{2})\d{10}(\d{2,3})?$/ 
-        }
-      end
-
-      # Returns a string containing the type of card from the list of known information below.
-      def self.type?(number)
-        return 'visa' if Base.gateway_mode == :test and ['1','2','3','success','failure','error'].include?(number.to_s)
-        
-        card_companies.each do |company, patterns|
-          return company if [patterns].flatten.any? { |pattern| number =~ pattern  } 
-        end
-
-        return nil
-      end
-
-      # Returns true if it validates. Optionally, you can pass a card type as an argument and make sure it is of the correct type.
-      # == References
-      # - http://perl.about.com/compute/perl/library/nosearch/P073000.htm
-      # - http://www.beachnet.com/~hstiles/cardtype.html
-      def self.valid_number?(number)
-        return true if Base.gateway_mode == :test and ['1','2','3','success','failure','error'].include?(number.to_s)
-        
-        return false unless number.to_s.length >= 13
-
-        sum = 0
-        for i in 0..number.length
-          weight = number[-1 * (i + 2), 1].to_i * (2 - (i % 2))
-          sum += (weight < 10) ? weight : weight - 9
-        end
-
-        (number[-1,1].to_i == (10 - sum % 10) % 10)
-      end
-
       # Show the card number, with all but last 4 numbers replace with "X". (XXXX-XXXX-XXXX-4338)
       def display_number
         "XXXX-XXXX-XXXX-#{last_digits}"
@@ -201,14 +121,6 @@ module ActiveMerchant #:nodoc:
         number.nil? ? "" : number.last(4)
       end
 
-      def month
-        expiry_date.month
-      end
-
-      def year
-        expiry_date.year
-      end
-
       def expiry_date
         ExpiryDate.new(@month, @year)
       end

data/lib/active_merchant/billing/credit_card_formatting.rb

@@ -0,0 +1,18 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module CreditCardFormatting
+      def format(number, format)
+        return '' if number.blank?
+        
+        case format
+        when :two_digits
+          sprintf("%.2i", number)[-2..-1]
+        when :four_digits
+          sprintf("%.4i", number)[-4..-1]
+        else
+          number
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/credit_card_methods.rb

@@ -0,0 +1,83 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # Convenience methods that can be included into a custom Credit Card object, such as an ActiveRecord based Credit Card object.
+    module CreditCardMethods
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      def valid_month?(month)
+        (1..12).include?(month)
+      end
+      
+      def valid_expiry_year?(year)
+        (Time.now.year..Time.now.year + 20).include?(year)
+      end
+      
+      def valid_start_year?(year)
+        year.to_s =~ /^\d{4}$/ && year.to_i > 1987
+      end
+      
+      def valid_issue_number?(number)
+        number.to_s =~ /^\d{1,2}$/
+      end
+      
+      module ClassMethods
+        # Returns true if it validates. Optionally, you can pass a card type as an argument and make sure it is of the correct type.
+        # == References
+        # - http://perl.about.com/compute/perl/library/nosearch/P073000.htm
+        # - http://www.beachnet.com/~hstiles/cardtype.html
+        def valid_number?(number)
+          return true if ActiveMerchant::Billing::Base.gateway_mode == :test and ['1','2','3','success','failure','error'].include?(number.to_s)
+
+          return false unless number.to_s.length >= 13
+
+          sum = 0
+          for i in 0..number.length
+            weight = number[-1 * (i + 2), 1].to_i * (2 - (i % 2))
+            sum += (weight < 10) ? weight : weight - 9
+          end
+
+          (number[-1,1].to_i == (10 - sum % 10) % 10)
+        end
+        
+        # Regular expressions for the known card companies
+        # == Known card types
+        #	 Card Type                         Prefix                           Length
+        #  --------------------------------------------------------------------------
+        #	 master                            51-55                            16
+        #	 visa                              4                                13, 16
+        #	 american_express                  34, 37                           15
+        #	 diners_club                       300-305, 36, 38                  14
+        #	 discover                          6011                             16
+        #	 jcb                               3                                16
+        #	 jcb                               2131, 1800                       15
+        #	 switch                            various                          16,18,19
+        #	 solo                              63, 6767                         16,18,19
+        def card_companies
+          { 
+            'visa' =>  /^4\d{12}(\d{3})?$/,
+            'master' =>  /^5[1-5]\d{14}$/,
+            'discover' =>  /^6011\d{12}$/,
+            'american_express' =>  /^3[47]\d{13}$/,
+            'diners_club' =>  /^3(0[0-5]|[68]\d)\d{11}$/,
+            'jcb' =>  /^(3\d{4}|2131|1800)\d{11}$/,
+            'switch' =>  [/^49(03(0[2-9]|3[5-9])|11(0[1-2]|7[4-9]|8[1-2])|36[0-9]{2})\d{10}(\d{2,3})?$/, /^564182\d{10}(\d{2,3})?$/, /^6(3(33[0-4][0-9])|759[0-9]{2})\d{10}(\d{2,3})?$/],
+            'solo' =>  /^6(3(34[5-9][0-9])|767[0-9]{2})\d{10}(\d{2,3})?$/ 
+          }
+        end
+
+        # Returns a string containing the type of card from the list of known information below.
+        def type?(number)
+          return 'visa' if ActiveMerchant::Billing::Base.gateway_mode == :test and ['1','2','3','success','failure','error'].include?(number.to_s)
+
+          card_companies.each do |company, patterns|
+            return company if [patterns].flatten.any? { |pattern| number =~ pattern  } 
+          end
+
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateway.rb

@@ -17,6 +17,7 @@ module ActiveMerchant #:nodoc:
     class Gateway
       include PostsData
       include RequiresParameters
+      include CreditCardFormatting
       
       # The format of the amounts used by the gateway
       # :dollars => '12.50'

data/lib/active_merchant/billing/gateways.rb

@@ -12,4 +12,5 @@ require 'active_merchant/billing/gateways/usa_epay'
 require 'active_merchant/billing/gateways/payflow'
 require 'active_merchant/billing/gateways/payflow_express'
 require 'active_merchant/billing/gateways/payflow_uk'
-require 'active_merchant/billing/gateways/payflow_express_uk'
+require 'active_merchant/billing/gateways/payflow_express_uk'
+require 'active_merchant/billing/gateways/data_cash'

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

@@ -0,0 +1,475 @@
+# Author::    MoneySpyder, http://moneyspyder.co.uk
+
+module ActiveMerchant
+  module Billing
+    # ActiveMerchant Datacash Gateway
+    # 
+    # Datacash allows a policy for CV2 checks. There is currently no way
+    # to modify this programatically. The policy may be changed in the
+    # add_credit_card method.
+    # 
+    class DataCashGateway < Gateway
+      
+      # Datacash server URLs
+      TEST_URL = 'https://testserver.datacash.com/Transaction'
+      LIVE_URL = 'https://mars.transaction.datacash.com/Transaction'
+      
+      # Different Card Transaction Types
+      AUTH_TYPE = 'auth'
+      CANCEL_TYPE = 'cancel'
+      FULFILL_TYPE = 'fulfill'
+      PRE_TYPE = 'pre'
+      
+      # Constant strings for use in the ExtendedPolicy complex element for
+      # CV2 checks
+      POLICY_ACCEPT = 'accept'
+      POLICY_REJECT = 'reject'
+      
+      #Datacash success code
+      DATACASH_SUCCESS = '1'
+      
+      # Class attributes
+      attr_reader :url 
+      attr_reader :response
+      attr_reader :options
+      
+      # Create a new DataCashGateway
+      # 
+      # The gateway requires that a valid :login and :password be passed
+      # in the options hash
+      # 
+      # Parameters:
+      #   -options:
+      #     :login - the Datacash account login
+      #     :password - the Datacash account password
+      #     :test - boolean, use the test or live Datacash url
+      #     
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end
+      
+      # Purchase the item straight away
+      # 
+      # Parameters:
+      #   -money: Money object for the total to be charged
+      #   -credit_card: ActiveMerchant::Billing::CreditCard details for the transaction
+      #   -options:
+      #
+      # Returns:
+      #   -ActiveRecord::Billing::Response object
+      #   
+      def purchase(money, credit_card, options = {})
+        if result = test_result_from_cc_number(credit_card.number)
+          return result
+        end
+      
+        request = build_purchase_or_authorization_request(AUTH_TYPE, money, credit_card, options)
+      
+        commit(request)
+      end
+      
+      # Authorize the transaction
+      # 
+      # Reserves the funds on the customer's credit card, but does not 
+      # charge the card.
+      # 
+      # Parameters:
+      #   -money: Money object for the total to be charged
+      #   -credit_card: ActiveMerchant::Billing::CreditCard details for the transaction
+      #   -options:
+      #
+      # Returns:
+      #   -ActiveRecord::Billing::Response object
+      #   
+      def authorize(money, credit_card, options = {})
+        if result = test_result_from_cc_number(credit_card.number)
+          return result
+        end
+        
+        request = build_purchase_or_authorization_request(PRE_TYPE, money, credit_card, options)
+        
+        commit(request)
+      end
+      
+      # Datacash requires both the reference and the authcode of the original
+      # authorization.  To maintain the same interface as the other
+      # gateways the two numbers are concatenated together with an ; separator as
+      # the authorization number returned by authorization
+      
+      # Captures the funds from an authorized transaction. 
+      # authorization must be a valid Datacash reference and :authcode must be
+      # a valid Datacash authcode from a prior authorized transaction.
+      # 
+      # This needs to create a 'historic txn' to fulfill
+      # 
+      # Parameters:
+      #   -money: Money object for the total to be charged
+      #   -authorization: the Datacash reference and authcode from the previous authorization
+      #
+      # Returns:
+      #   -ActiveRecord::Billing::Response object
+      #   
+      def capture(money, authorization, options = {})
+        request = build_void_or_capture_request(FULFILL_TYPE, money, authorization, options)
+
+        commit(request)
+      end                    
+      
+      # Void a previous transaction
+      # 
+      # This needs to create a 'historic txn' to fulfil
+      # 
+      # Parameters:
+      #   -authorization: the Datacash reference from the previous authorization
+      #
+      # Returns:
+      #   -ActiveRecord::Billing::Response object
+      #   
+      def void(authorization, options = {})
+        request = build_void_or_capture_request(CANCEL_TYPE, nil, authorization, options)
+        
+        commit(request)
+      end
+      
+      # From the DataCash docs; Page 13, the following cards are
+      # usable
+      # 
+      # American Express, ATM, Carte Blanche, Diners Club, Discover,
+      # EnRoute, GE Capital, JCB, Laser, Maestro, Mastercard, Solo,
+      # Switch, Unknown, Visa, Visa Delta, VISA Electron, Visa Purchasing
+      # 
+      # Parameters:
+      #   -none
+      # 
+      # Returns:
+      #   -the list of all supported cards
+      #   
+      def self.supported_cardtypes
+        [ :visa, :master, :american_express, :discover, :diners_club, :jcb, 
+          :switch, :solo ]
+      end
+      
+      # Return whether or not the gateway is in test mode
+      # 
+      # Parameters:
+      #   -none
+      # 
+      # Returns:
+      #   -boolean
+      #   
+      def test?
+        @options[:test] || Base.gateway_mode == :test
+      end
+    
+      private                         
+      # Create the xml document for a 'cancel' or 'fulfill' transaction.
+      # 
+      # Final XML should look like:
+      # <Request>
+      #  <Authentication>
+      #    <client>99000001</client>
+      #    <password>******</password>
+      #  </Authentication>
+      #  <Transaction>
+      #    <TxnDetails>
+      #      <amount>25.00</amount>
+      #    </TxnDetails>
+      #    <HistoricTxn>
+      #      <reference>4900200000000001</reference>
+      #      <authcode>A6</authcode>
+      #      <method>fulfill</method>
+      #    </HistoricTxn>
+      #  </Transaction>
+      # </Request>
+      # 
+      # Parameters:
+      #   -type must be FULFILL_TYPE or CANCEL_TYPE
+      #   -money - optional - A money object with the price and currency
+      #   -authorization - the Datacash reference number from a previous
+      #                    succesful authorize transaction
+      #   -authcode - the Datacash authcode
+      #   -order_id - The merchants reference
+      #   
+      # Returns:
+      #   -Builder xml document
+      #
+      def build_void_or_capture_request(type, money, authorization, options)
+        reference, auth_code = authorization.to_s.split(';')
+        
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.instruct!
+        xml.tag! :Request do
+          add_authentication(xml)
+          
+          xml.tag! :Transaction do
+            xml.tag! :HistoricTxn do
+              xml.tag! :reference, reference
+              xml.tag! :authcode, auth_code
+              xml.tag! :method, type
+            end
+            
+            if money
+              xml.tag! :TxnDetails do
+                xml.tag! :merchantreference, format_reference_number(options[:order_id])
+                xml.tag! :amount, amount(money), :currency => currency(money)
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+      
+      # Create the xml document for an 'auth' or 'pre' transaction.
+      # 
+      # Final XML should look like:
+      # 
+      # <Request>
+      #  <Authentication>
+      #    <client>99000000</client>
+      #    <password>*******</password>
+      #  </Authentication>
+      #  <Transaction>
+      #    <TxnDetails>
+      #      <merchantreference>123456</merchantreference>
+      #      <amount currency="EUR">10.00</amount>
+      #    </TxnDetails>
+      #    <CardTxn>
+      #      <Card>
+      #        <pan>4444********1111</pan>
+      #        <expirydate>03/04</expirydate>
+      #        <Cv2Avs>
+      #          <street_address1>Flat 7</street_address1>
+      #          <street_address2>89 Jumble
+      #               Street</street_address2>
+      #          <street_address3>Mytown</street_address3>
+      #          <postcode>AV12FR</postcode>
+      #          <cv2>123</cv2>
+      #           <ExtendedPolicy>
+      #             <cv2_policy notprovided="reject"
+      #                          notchecked="accept"
+      #                          matched="accept"
+      #                          notmatched="reject"
+      #                          partialmatch="reject"/>
+      #             <postcode_policy notprovided="reject"
+      #                          notchecked="accept"
+      #                          matched="accept"
+      #                          notmatched="reject"
+      #                          partialmatch="accept"/>
+      #             <address_policy notprovided="reject"
+      #                          notchecked="accept"
+      #                          matched="accept"
+      #                          notmatched="reject"
+      #                          partialmatch="accept"/>
+      #           </ExtendedPolicy>
+      #        </Cv2Avs>
+      #      </Card>
+      #      <method>auth, </method>
+      #    </CardTxn>
+      #  </Transaction>
+      # </Request>
+      # 
+      # Parameters:
+      #   -type must be 'auth' or 'pre'
+      #   -money - A money object with the price and currency
+      #   -credit_card - The credit_card details to use
+      #   -options:
+      #     :order_id is the merchant reference number
+      #     :billing_address is the billing address for the cc
+      #     :address is the delivery address
+      #   
+      # Returns:
+      #   -xml: Builder document containing the markup
+      #
+      def build_purchase_or_authorization_request(type, money, credit_card, options)
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.instruct!
+        xml.tag! :Request do
+          add_authentication(xml)
+          
+          xml.tag! :Transaction do
+            xml.tag! :CardTxn do
+              xml.tag! :method, type
+              
+              add_credit_card(xml, credit_card, options[:billing_address] || options[:address])
+            end
+            xml.tag! :TxnDetails do
+              xml.tag! :merchantreference, format_reference_number(options[:order_id])
+              xml.tag! :amount, amount(money), :currency => currency(money)
+            end
+          end
+        end
+        xml.target!
+      end
+      
+      # Adds the authentication element to the passed builder xml doc
+      # 
+      # Parameters:
+      #   -xml: Builder document that is being built up
+      #   
+      # Returns:
+      #   -none: The results is stored in the passed xml document
+      #   
+      def add_authentication(xml)
+        xml.tag! :Authentication do
+          xml.tag! :client, @options[:login]
+          xml.tag! :password, @options[:password]
+        end
+      end
+      
+      # Add credit_card detals to the passed XML Builder doc
+      # 
+      # Parameters:
+      #   -xml: Builder document that is being built up
+      #   -credit_card: ActiveMerchant::Billing::CreditCard object
+      #   -billing_address: Hash containing all of the billing address details
+      #   
+      # Returns:
+      #   -none: The results is stored in the passed xml document
+      #   
+      def add_credit_card(xml, credit_card, address)
+        xml.tag! :Card do
+          
+          # DataCash calls the CC number 'pan'
+          xml.tag! :pan, credit_card.number
+          xml.tag! :expirydate, format_date(credit_card.month, credit_card.year)
+          
+          # optional values - for Solo etc
+          if [ 'switch', 'solo' ].include?(credit_card.type.to_s)
+            
+            xml.tag! :issuenumber, credit_card.issue_number unless credit_card.issue_number.blank?
+            
+            if !credit_card.start_month.blank? && !credit_card.start_year.blank?
+              xml.tag! :startdate, format_date(credit_card.start_month, credit_card.start_year)
+            end
+          end
+            
+          xml.tag! :Cv2Avs do
+            xml.tag! :cv2, credit_card.verification_value if credit_card.verification_value?
+            xml.tag! :street_address1, address[:address1] unless address[:address1].blank?
+            xml.tag! :street_address2, address[:address2] unless address[:address2].blank?
+            xml.tag! :street_address3, address[:address3] unless address[:address3].blank?
+            xml.tag! :street_address4, address[:address4] unless address[:address4].blank?
+            xml.tag! :postcode, address[:zip] unless address[:zip].blank?
+            
+            # The ExtendedPolicy defines what to do when the passed data 
+            # matches, or not...
+            # 
+            # All of the following elements MUST be present for the
+            # xml to be valid (or can drop the ExtendedPolicy and use
+            # a predefined one
+            xml.tag! :ExtendedPolicy do
+              xml.tag! :cv2_policy, 
+              :notprovided =>   POLICY_REJECT,
+              :notchecked =>    POLICY_REJECT,
+              :matched =>       POLICY_ACCEPT,
+              :notmatched =>    POLICY_REJECT,
+              :partialmatch =>  POLICY_REJECT
+              xml.tag! :postcode_policy,
+              :notprovided =>   POLICY_ACCEPT,
+              :notchecked =>    POLICY_ACCEPT,
+              :matched =>       POLICY_ACCEPT,
+              :notmatched =>    POLICY_REJECT,
+              :partialmatch =>  POLICY_ACCEPT
+              xml.tag! :address_policy, 
+              :notprovided =>   POLICY_ACCEPT,
+              :notchecked =>    POLICY_ACCEPT,
+              :matched =>       POLICY_ACCEPT,
+              :notmatched =>    POLICY_REJECT,
+              :partialmatch =>  POLICY_ACCEPT
+            end
+          end
+        end
+      end
+      
+      # Send the passed data to DataCash for processing
+      # 
+      # Parameters:
+      #   -request: The XML data that is to be sent to Datacash
+      #   
+      # Returns:
+      #   - ActiveMerchant::Billing::Response object
+      #   
+      def commit(request)
+        url = test? ? TEST_URL : LIVE_URL
+  
+        @response = parse(ssl_post(url, request))      
+        success = @response[:status] == DATACASH_SUCCESS
+        message = @response[:reason]
+        
+        Response.new(success, message, @response,
+                     :test => test?,
+                     :authorization => "#{@response[:datacash_reference]};#{@response[:authcode]}"
+        )
+      end
+      
+      # Find the currency of the Money object passed
+      # 
+      # Parameters:
+      #   -money: The money object that we are looking at
+      #   
+      # Returns:
+      #   -string: The three digit currency code (These are
+      #            ISO 4217 codes)
+      #            
+      def currency(money)
+        money.respond_to?(:currency) ? money.currency : 'GBP'
+      end
+      
+      # Returns a date string in the format Datacash expects
+      # 
+      # Parameters:
+      #   -month: integer, the month
+      #   -year: integer, the year
+      # 
+      # Returns:
+      #   -String: date in MM/YY format
+      #
+      def format_date(month, year)
+        "#{format(month,:two_digits)}/#{format(year, :two_digits)}"
+      end
+      
+      # Parse the datacash response and create a Response object
+      #
+      # Parameters:
+      #   -body: The XML returned from Datacash
+      # 
+      # Returns:
+      #   -a hash with all of the values returned in the Datacash XML response
+      # 
+      def parse(body)
+        
+        response = {}
+        xml = REXML::Document.new(body)
+        root = REXML::XPath.first(xml, "//Response")
+        
+        root.elements.to_a.each do |node|
+          parse_element(response, node)
+        end
+        
+        response
+      end     
+      
+      # Parse an xml element
+      #
+      # Parameters:
+      #   -response: The hash that the values are being returned in
+      #   -node: The node that is currently being read
+      # 
+      # Returns:
+      # -  none (results are stored in the passed hash)
+      def parse_element(response, node)
+        if node.has_elements?
+          node.elements.each{|e| parse_element(response, e) }
+        else
+          response[node.name.underscore.to_sym] = node.text
+        end
+      end
+      
+      def format_reference_number(number)
+        number.to_s.gsub(/[^A-Za-z0-9]/, '').rjust(6, "0")
+      end
+    end
+  end
+end