activemerchant 1.42.7 → 1.42.8

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NDRjYjY2NmNjZWUyNDMwMjdhOTZjOGMyMzJjOTUxYWMxNjFlNjVkNw==
-  data.tar.gz: !binary |-
-    ZTFjN2I2ZjQ3ZTdkZTIwZWY0ZGY0OTFhNzhjOTkwYWIxNDFlYTI3OA==
+SHA1:
+  metadata.gz: 81edb8d2513f065dd9170ead1d0d6f72d4fc39c8
+  data.tar.gz: b14933f6c29ebd5ed555e12238a29828a959687a
 SHA512:
-  metadata.gz: !binary |-
-    OTZiMWRlNzE0OWZmOWQwZjk2NjNlZmJjYmYxOGNhMWIzMjk4ZDAxMDg5MjZk
-    Y2I3ZDVhYjkzZDA4NTAyYjk0ZDU3ZjZkODAyMmEzOWVjMjg1OTJlNmRiYzg4
-    YTQ5YTc4ZGRjMmVmZGU5N2ZlMWI0MjdiNmRjZjUyZmVlN2NhMzU=
-  data.tar.gz: !binary |-
-    YTY3ZGViYTg2MTIxOTFhZmFhMzE5Y2JiZmYxNzZlMzMzMDJhNDYwNTA1OTE0
-    ZDEzNWQ1OGYyZjJkOTM5ODE0OGViNGFiNmFmNjg3NDczMmQyOTI1OWYyMDZi
-    ZTZjYzVkZWM5ZTFhNzhkOGU4MTc3YWY1NGI3OWMyM2Q0OGIzYTA=
+  metadata.gz: 9350271f4a9016fd5c8d0113def4e0ec6a654578d63d824b07647a59128110f6b9bd2a33c3205ad2c89debe1b013b555d08cbd51e68b2333a24a0f98a7a20326
+  data.tar.gz: 3ce7cf004ee44048d02e6805dd2b63808c104a6cad0d42980246707fb8d50a302d4798c63ced00a2ff7526bedf93e84dfd88ebf2adac2326f10a5a51666bc32c

data.tar.gz.sig

@@ -1,3 +1,2 @@
-<v;�5�Z����gw��@��>u�O5�h~�����P���n*L�%_��D�,c�g�`v-v����!��!>7f2s���f���B!
-	O	�,��i���Ӛ�@�%k�Ĩs�}�E|@�o
�g��R��L9l0.7�j��p����}V�
-,�!8
TD)�(�J3��"��;�"i�l���5�B�
+e��k�M����6Q�)Q	��*ki-1P������{��2\v2����68B��kU�?i����]CE1m����\�3�׵Jh�`�T�4���U���n�œM������B�S֌����u�zL�u������e2Q�b"ͯu��7<��S���^A-��j�n+/}n/U.R �'>>lޡvy��o�>���?i#]Q�\$z
+��c��׵�"P����q�x�i�[(�Wa�u�[��t)J�(�Tx���;

data/CHANGELOG

@@ -1,5 +1,15 @@
 = ActiveMerchant CHANGELOG
 
+== Version 1.42.8 (April 4, 2014)
+
+* Cecabank: Handle invalid xml response body [duff]
+* Wirecard: Capture error code in the response [duff]
+* Litle: Remove gem dependency [duff]
+* Litle: Fix case of missing address parts [duff]
+* Universal: Add universal offsite API implementation [bslobodin]
+* Iridium: Add more currencies [bslobodin]
+* iDeal: Add Mollie iDeal offsite implementation [wvanbergen, maartenvg]
+
 == Version 1.42.7 (March 18, 2014)
 
 * SagePay: Add support for ReferrerID [markabe]

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

@@ -113,30 +113,24 @@ module ActiveMerchant #:nodoc:
         root = REXML::Document.new(body).root
 
         response[:success] = (root.attributes['valor'] == "OK")
-
-        #common params to all responses
         response[:date] = root.attributes['fecha']
         response[:operation_number] = root.attributes['numeroOperacion']
         response[:message] = root.attributes['valor']
 
-        #success
         if root.elements['OPERACION']
           response[:operation_type] = root.elements['OPERACION'].attributes['tipo']
           response[:amount] =  root.elements['OPERACION/importe'].text.strip
         end
 
-        #optional params
         response[:description] = root.elements['OPERACION/descripcion'].text if root.elements['OPERACION/descripcion']
         response[:authorization_number] = root.elements['OPERACION/numeroAutorizacion'].text if root.elements['OPERACION/numeroAutorizacion']
         response[:reference] = root.elements['OPERACION/referencia'].text if root.elements['OPERACION/referencia']
         response[:pan] = root.elements['OPERACION/pan'].text if root.elements['OPERACION/pan']
 
         if root.elements['ERROR']
-          #error
           response[:error_code] = root.elements['ERROR/codigo'].text
           response[:error_message] = root.elements['ERROR/descripcion'].text
         else
-          #authorization
           if("000" == root.elements['OPERACION'].attributes['numeroOperacion'])
             if(root.elements['OPERACION/numeroAutorizacion'])
               response[:authorization] = root.elements['OPERACION/numeroAutorizacion'].text
@@ -146,6 +140,12 @@ module ActiveMerchant #:nodoc:
           end
         end
 
+        return response
+
+      rescue REXML::ParseException => e
+        response[:success] = false
+        response[:message] = "Unable to parse the response."
+        response[:error_message] = e.message
         response
       end
 

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

@@ -24,13 +24,186 @@ module ActiveMerchant #:nodoc:
       self.display_name = 'Iridium'
 
       CURRENCY_CODES = {
+        "AED" => '784',
+        "AFN" => '971',
+        "ALL" => '008',
+        "AMD" => '051',
+        "ANG" => '532',
+        "AOA" => '973',
+        "ARS" => '032',
         "AUD" => '036',
+        "AWG" => '533',
+        "AZN" => '944',
+        "BAM" => '977',
+        "BBD" => '052',
+        "BDT" => '050',
+        "BGN" => '975',
+        "BHD" => '048',
+        "BIF" => '108',
+        "BMD" => '060',
+        "BND" => '096',
+        "BOB" => '068',
+        "BOV" => '984',
+        "BRL" => '986',
+        "BSD" => '044',
+        "BTN" => '064',
+        "BWP" => '072',
+        "BYR" => '974',
+        "BZD" => '084',
         "CAD" => '124',
+        "CDF" => '976',
+        "CHE" => '947',
+        "CHF" => '756',
+        "CHW" => '948',
+        "CLF" => '990',
+        "CLP" => '152',
+        "CNY" => '156',
+        "COP" => '170',
+        "COU" => '970',
+        "CRC" => '188',
+        "CUP" => '192',
+        "CVE" => '132',
+        "CYP" => '196',
+        "CZK" => '203',
+        "DJF" => '262',
+        "DKK" => '208',
+        "DOP" => '214',
+        "DZD" => '012',
+        "EEK" => '233',
+        "EGP" => '818',
+        "ERN" => '232',
+        "ETB" => '230',
         "EUR" => '978',
+        "FJD" => '242',
+        "FKP" => '238',
         "GBP" => '826',
+        "GEL" => '981',
+        "GHS" => '288',
+        "GIP" => '292',
+        "GMD" => '270',
+        "GNF" => '324',
+        "GTQ" => '320',
+        "GYD" => '328',
+        "HKD" => '344',
+        "HNL" => '340',
+        "HRK" => '191',
+        "HTG" => '332',
+        "HUF" => '348',
+        "IDR" => '360',
+        "ILS" => '376',
+        "INR" => '356',
+        "IQD" => '368',
+        "IRR" => '364',
+        "ISK" => '352',
+        "JMD" => '388',
+        "JOD" => '400',
+        "JPY" => '392',
+        "KES" => '404',
+        "KGS" => '417',
+        "KHR" => '116',
+        "KMF" => '174',
+        "KPW" => '408',
+        "KRW" => '410',
+        "KWD" => '414',
+        "KYD" => '136',
+        "KZT" => '398',
+        "LAK" => '418',
+        "LBP" => '422',
+        "LKR" => '144',
+        "LRD" => '430',
+        "LSL" => '426',
+        "LTL" => '440',
+        "LVL" => '428',
+        "LYD" => '434',
+        "MAD" => '504',
+        "MDL" => '498',
+        "MGA" => '969',
+        "MKD" => '807',
+        "MMK" => '104',
+        "MNT" => '496',
+        "MOP" => '446',
+        "MRO" => '478',
+        "MTL" => '470',
+        "MUR" => '480',
+        "MVR" => '462',
+        "MWK" => '454',
         "MXN" => '484',
+        "MXV" => '979',
+        "MYR" => '458',
+        "MZN" => '943',
+        "NAD" => '516',
+        "NGN" => '566',
+        "NIO" => '558',
+        "NOK" => '578',
+        "NPR" => '524',
         "NZD" => '554',
+        "OMR" => '512',
+        "PAB" => '590',
+        "PEN" => '604',
+        "PGK" => '598',
+        "PHP" => '608',
+        "PKR" => '586',
+        "PLN" => '985',
+        "PYG" => '600',
+        "QAR" => '634',
+        "ROL" => '642',
+        "RON" => '946',
+        "RSD" => '941',
+        "RUB" => '643',
+        "RWF" => '646',
+        "SAR" => '682',
+        "SBD" => '090',
+        "SCR" => '690',
+        "SDG" => '938',
+        "SEK" => '752',
+        "SGD" => '702',
+        "SHP" => '654',
+        "SKK" => '703',
+        "SLL" => '694',
+        "SOS" => '706',
+        "SRD" => '968',
+        "STD" => '678',
+        "SYP" => '760',
+        "SZL" => '748',
+        "THB" => '764',
+        "TJS" => '972',
+        "TMM" => '795',
+        "TND" => '788',
+        "TOP" => '776',
+        "TRY" => '949',
+        "TTD" => '780',
+        "TWD" => '901',
+        "TZS" => '834',
+        "UAH" => '980',
+        "UGX" => '800',
         "USD" => '840',
+        "USN" => '997',
+        "USS" => '998',
+        "UYU" => '858',
+        "UZS" => '860',
+        "VEB" => '862',
+        "VND" => '704',
+        "VUV" => '548',
+        "WST" => '882',
+        "XAF" => '950',
+        "XAG" => '961',
+        "XAU" => '959',
+        "XBA" => '955',
+        "XBB" => '956',
+        "XBC" => '957',
+        "XBD" => '958',
+        "XCD" => '951',
+        "XDR" => '960',
+        "XOF" => '952',
+        "XPD" => '964',
+        "XPF" => '953',
+        "XPT" => '962',
+        "XTS" => '963',
+        "XXX" => '999',
+        "YER" => '886',
+        "ZAR" => '710',
+        "ZMK" => '894',
+        "ZWD" => '716',
       }
 
       def initialize(options = {})

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

@@ -1,141 +1,119 @@
+require 'nokogiri'
+
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class LitleGateway < Gateway
-      # Specific to Litle options:
-      # * <tt>:merchant_id</tt> - Merchant Id assigned by Litle
-      # * <tt>:user</tt> - Username assigned by Litle
-      # * <tt>:password</tt> - Password assigned by Litle
-      # * <tt>:version</tt> - The version of the api you are using (eg, '8.10')
-      # * <tt>:proxy_addr</tt> - Proxy address - nil if not needed
-      # * <tt>:proxy_port</tt> - Proxy port - nil if not needed
-      # * <tt>:url</tt> - URL assigned by Litle (for testing, use the sandbox)
-      #
-      # Standard Active Merchant options
-      # * <tt>:order_id</tt> - The order number
-      # * <tt>:ip</tt> - The IP address of the customer making the purchase
-      # * <tt>:customer</tt> - The name, customer number, or other information that identifies the customer
-      # * <tt>:invoice</tt> - The invoice number
-      # * <tt>:merchant</tt> - The name or description of the merchant offering the product
-      # * <tt>:description</tt> - A description of the transaction
-      # * <tt>:email</tt> - The email address of the customer
-      # * <tt>:currency</tt> - The currency of the transaction.  Only important when you are using a currency that is not the default with a gateway that supports multiple currencies.
-      # * <tt>:billing_address</tt> - A hash containing the billing address of the customer.
-      # * <tt>:shipping_address</tt> - A hash containing the shipping address of the customer.
-      #
-      # The <tt>:billing_address</tt>, and <tt>:shipping_address</tt> hashes can have the following keys:
-      #
-      # * <tt>:name</tt> - The full name of the customer.
-      # * <tt>:company</tt> - The company name of the customer.
-      # * <tt>:address1</tt> - The primary street address of the customer.
-      # * <tt>:address2</tt> - Additional line of address information.
-      # * <tt>:city</tt> - The city of the customer.
-      # * <tt>:state</tt> - The state of the customer.  The 2 digit code for US and Canadian addresses. The full name of the state or province for foreign addresses.
-      # * <tt>:country</tt> - The [ISO 3166-1-alpha-2 code](http://www.iso.org/iso/country_codes/iso_3166_code_lists/english_country_names_and_code_elements.htm) for the customer.
-      # * <tt>:zip</tt> - The zip or postal code of the customer.
-      # * <tt>:phone</tt> - The phone number of the customer.
+      SCHEMA_VERSION = '8.18'
 
       self.test_url = 'https://www.testlitle.com/sandbox/communicator/online'
       self.live_url = 'https://payments.litle.com/vap/communicator/online'
 
-      LITLE_SCHEMA_VERSION     = '8.13'
-
-      # The countries the gateway supports merchants from as 2 digit ISO country codes
       self.supported_countries = ['US']
-
-      # The card types supported by the payment gateway
+      self.default_currency = 'USD'
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
 
-      # The homepage URL of the gateway
-      self.homepage_url        = 'http://www.litle.com/'
-
-      # The name of the gateway
-      self.display_name        = 'Litle & Co.'
+      self.homepage_url = 'http://www.litle.com/'
+      self.display_name = 'Litle & Co.'
 
-      self.default_currency = 'USD'
+      # Public: Create a new Litle gateway.
+      #
+      # options - A hash of options:
+      #           :login         - The user.
+      #           :password      - The password.
+      #           :merchant_id   - The merchant id.
+      def initialize(options={})
+        requires!(options, :login, :password, :merchant_id)
+        super
+      end
 
-      def initialize(options = {})
-        begin
-          require 'LitleOnline'
-        rescue LoadError
-          raise "Could not load the LitleOnline gem (> 08.15.0).  Use `gem install LitleOnline` to install it."
+      def purchase(money, payment_method, options={})
+        request = build_xml_request do |doc|
+          add_authentication(doc)
+          doc.sale(transaction_attributes(options)) do
+            add_auth_purchase_params(doc, money, payment_method, options)
+          end
         end
 
-        if wiredump_device
-          LitleOnline::Configuration.logger = ((Logger === wiredump_device) ? wiredump_device : Logger.new(wiredump_device))
-          LitleOnline::Configuration.logger.level = Logger::DEBUG
-        else
-          LitleOnline::Configuration.logger = Logger.new(STDOUT)
-          LitleOnline::Configuration.logger.level = Logger::WARN
+        commit(:sale, request)
+      end
+
+      def authorize(money, payment_method, options={})
+        request = build_xml_request do |doc|
+          add_authentication(doc)
+          doc.authorization(transaction_attributes(options)) do
+            add_auth_purchase_params(doc, money, payment_method, options)
+          end
         end
 
-        @litle = LitleOnline::LitleOnlineRequest.new
+        commit(:authorization, request)
+      end
 
-        options[:version]  ||= LITLE_SCHEMA_VERSION
-        options[:merchant] ||= 'Default Report Group'
-        options[:user]     ||= options[:login]
+      def capture(money, authorization, options={})
+        transaction_id, kind = split_authorization(authorization)
 
-        requires!(options, :merchant_id, :user, :password, :merchant, :version)
+        request = build_xml_request do |doc|
+          add_authentication(doc)
+          doc.capture_(transaction_attributes(options)) do
+            doc.litleTxnId(transaction_id)
+            doc.amount(money) if money
+          end
+        end
 
-        super
+        commit(:capture, request)
       end
 
-      def authorize(money, creditcard_or_token, options = {})
-        to_pass = build_authorize_request(money, creditcard_or_token, options)
-        build_response(:authorization, @litle.authorization(to_pass))
+      def credit(money, authorization, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, authorization, options)
       end
 
-      def purchase(money, creditcard_or_token, options = {})
-        to_pass = build_purchase_request(money, creditcard_or_token, options)
-        build_response(:sale, @litle.sale(to_pass))
+      def refund(money, authorization, options={})
+        transaction_id, kind = split_authorization(authorization)
+
+        request = build_xml_request do |doc|
+          add_authentication(doc)
+          doc.credit(transaction_attributes(options)) do
+            doc.litleTxnId(transaction_id)
+            doc.amount(money) if money
+          end
+        end
+
+        commit(:credit, request)
       end
 
-      def capture(money, authorization, options = {})
+      def void(authorization, options={})
         transaction_id, kind = split_authorization(authorization)
-        to_pass = create_capture_hash(money, transaction_id, options)
-        build_response(:capture, @litle.capture(to_pass))
-      end
 
-      # Note: Litle requires that authorization requests be voided via auth_reversal
-      # and other requests via void. To maintain the same interface as the other
-      # gateways the transaction_id and the kind of transaction are concatenated
-      # together with a ; separator (e.g. 1234;authorization)
-      #
-      # A partial auth_reversal can be accomplished by passing :amount as an option
-      def void(identification, options = {})
-        transaction_id, kind = split_authorization(identification)
-        if(kind == 'authorization')
-          to_pass = create_auth_reversal_hash(transaction_id, options[:amount], options)
-          build_response(:authReversal, @litle.auth_reversal(to_pass))
-        else
-          to_pass = create_void_hash(transaction_id, options)
-          build_response(:void, @litle.void(to_pass))
+        request = build_xml_request do |doc|
+          add_authentication(doc)
+          doc.send(void_type(kind), transaction_attributes(options)) do
+            doc.litleTxnId(transaction_id)
+          end
         end
-      end
 
-      def refund(money, authorization, options = {})
-        to_pass = build_credit_request(money, authorization, options)
-        build_response(:credit, @litle.credit(to_pass))
+        commit(void_type(kind), request)
       end
 
-      def credit(money, authorization, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
-        refund(money, authorization, options)
-      end
+      def store(creditcard, options = {})
+        request = build_xml_request do |doc|
+          add_authentication(doc)
+          doc.registerTokenRequest(transaction_attributes(options)) do
+            doc.orderId(truncated(options[:order_id]))
+            doc.accountNumber(creditcard.number)
+          end
+        end
 
-      def store(creditcard_or_paypage_registration_id, options = {})
-        to_pass = create_token_hash(creditcard_or_paypage_registration_id, options)
-        build_response(:registerToken, @litle.register_token_request(to_pass), %w(000 801 802))
+        commit(:registerToken, request)
       end
 
       private
-
       CARD_TYPE = {
-          'visa'             => 'VI',
-          'master'           => 'MC',
-          'american_express' => 'AX',
-          'discover'         => 'DI',
-          'jcb'              => 'DI',
-          'diners_club'      => 'DI'
+        'visa'             => 'VI',
+        'master'           => 'MC',
+        'american_express' => 'AX',
+        'discover'         => 'DI',
+        'jcb'              => 'JC',
+        'diners_club'      => 'DC'
       }
 
       AVS_RESPONSE_CODE = {
@@ -156,410 +134,172 @@ module ActiveMerchant #:nodoc:
           '40' => 'E'
       }
 
-      def url
-        return @options[:url] if @options[:url].present?
-
-        test? ? self.test_url : self.live_url
-      end
-
-      def build_response(kind, litle_response, valid_responses=%w(000))
-        response = Hash.from_xml(litle_response.raw_xml.to_s)['litleOnlineResponse']
-
-        if response['response'] == "0"
-          detail        = response["#{kind}Response"]
-          fraud         = fraud_result(detail)
-          Response.new(
-              valid_responses.include?(detail['response']),
-              detail['message'],
-              { litleOnlineResponse: response, response_code: detail['response'] },
-              authorization: authorization_from(detail, kind),
-              avs_result: { :code => fraud['avs'] },
-              cvv_result: fraud['cvv'],
-              test: test?
-          )
-        else
-          Response.new(false, response['message'], :litleOnlineResponse => response, :test => test?)
-        end
+      def void_type(kind)
+        (kind == 'authorization') ? :authReversal : :void
       end
 
-      # Generates an authorization string of the appropriate id and the kind of transaction
-      # See #void for how the kind is used
-      def authorization_from(litle_response, kind)
-        case kind
-        when :registerToken
-          authorization = litle_response['litleToken']
-        else
-          authorization = [litle_response['litleTxnId'], kind.to_s].join(";")
+      def add_authentication(doc)
+        doc.authentication do
+          doc.user(@options[:login])
+          doc.password(@options[:password])
         end
       end
 
-      def split_authorization(authorization)
-        transaction_id, kind = authorization.to_s.split(';')
-        [transaction_id, kind]
-      end
-
-      def build_authorize_request(money, creditcard_or_token, options)
-        payment_method = build_payment_method(creditcard_or_token, options)
-
-        hash = create_hash(money, options)
-
-        add_creditcard_or_cardtoken_hash(hash, payment_method)
-
-        hash
+      def add_auth_purchase_params(doc, money, payment_method, options)
+        doc.orderId(truncated(options[:order_id]))
+        doc.amount(money)
+        doc.orderSource('ecommerce')
+        add_billing_address(doc, payment_method, options)
+        add_shipping_address(doc, payment_method, options)
+        add_payment_method(doc, payment_method)
       end
 
-      def build_purchase_request(money, creditcard_or_token, options)
-        payment_method = build_payment_method(creditcard_or_token, options)
-
-        hash = create_hash(money, options)
-
-        add_creditcard_or_cardtoken_hash(hash, payment_method)
-
-        hash
+      def add_payment_method(doc, payment_method)
+        if payment_method.is_a?(String)
+          doc.token do
+            doc.litleToken(payment_method)
+          end
+        else
+          doc.card do
+            doc.type_(CARD_TYPE[payment_method.brand])
+            doc.number(payment_method.number)
+            doc.expDate(exp_date(payment_method))
+            doc.cardValidationNum(payment_method.verification_value)
+          end
+        end
       end
 
-      def build_credit_request(money, identification_or_token, options)
-        payment_method = build_payment_method(identification_or_token, options)
+      def add_billing_address(doc, payment_method, options)
+        return if payment_method.is_a?(String)
 
-        hash = create_hash(money, options)
+        doc.billToAddress do
+          doc.name(payment_method.name)
+          doc.email(options[:email]) if options[:email]
 
-        add_identification_or_cardtoken_hash(hash, payment_method)
-
-        unless payment_method.is_a?(LitleCardToken)
-          hash['orderSource'] = nil
-          hash['orderId']     = nil
+          add_address(doc, options[:billing_address])
         end
-
-        hash
       end
 
-      def build_payment_method(payment_method, options)
-        result = payment_method
+      def add_shipping_address(doc, payment_method, options)
+        return if payment_method.is_a?(String)
 
-        # Build instance of the LitleCardToken class for internal use if this is a token request.
-        if payment_method.is_a?(String) && options.has_key?(:token)
-          result                    = LitleCardToken.new(:token => payment_method)
-          result.month              = options[:token][:month]
-          result.year               = options[:token][:year]
-          result.verification_value = options[:token][:verification_value]
-          result.brand              = options[:token][:brand]
+        doc.shipToAddress do
+          add_address(doc, options[:shipping_address])
         end
-
-        result
       end
 
-      def add_creditcard_or_cardtoken_hash(hash, creditcard_or_cardtoken)
-        if creditcard_or_cardtoken.is_a?(LitleCardToken)
-          add_cardtoken_hash(hash, creditcard_or_cardtoken)
-        else
-          add_creditcard_hash(hash, creditcard_or_cardtoken)
-        end
+      def add_address(doc, address)
+        return unless address
+
+        doc.companyName(address[:company]) unless address[:company].blank?
+        doc.addressLine1(address[:address1]) unless address[:address1].blank?
+        doc.addressLine2(address[:address2]) unless address[:address2].blank?
+        doc.city(address[:city]) unless address[:city].blank?
+        doc.state(address[:state]) unless address[:state].blank?
+        doc.zip(address[:zip]) unless address[:zip].blank?
+        doc.country(address[:country]) unless address[:country].blank?
+        doc.phone(address[:phone]) unless address[:phone].blank?
       end
 
-      def add_identification_or_cardtoken_hash(hash, identification_or_cardtoken)
-        if identification_or_cardtoken.is_a?(LitleCardToken)
-          add_cardtoken_hash(hash, identification_or_cardtoken)
-        else
-          transaction_id, kind = split_authorization(identification_or_cardtoken)
-          hash['litleTxnId'] = transaction_id
-        end
+      def exp_date(payment_method)
+        "#{format(payment_method.month, :two_digits)}#{format(payment_method.year, :two_digits)}"
       end
 
-      def add_cardtoken_hash(hash, cardtoken)
-        token_info               = {}
-        token_info['litleToken'] = cardtoken.token
-        token_info['expDate'] = cardtoken.exp_date if cardtoken.exp_date?
-        token_info['cardValidationNum'] = cardtoken.verification_value unless cardtoken.verification_value.blank?
-        token_info['type'] = cardtoken.type unless cardtoken.type.blank?
+      def parse(kind, xml)
+        parsed = {}
+
+        doc = Nokogiri::XML(xml).remove_namespaces!
+        doc.xpath("//litleOnlineResponse/#{kind}Response/*").each do |node|
+          if (node.elements.empty?)
+            parsed[node.name.to_sym] = node.text
+          else
+            node.elements.each do |childnode|
+              name = "#{node.name}_#{childnode.name}"
+              parsed[name.to_sym] = childnode.text
+            end
+          end
+        end
 
-        hash['token'] = token_info
-        hash
+        parsed
       end
 
-      def add_creditcard_hash(hash, creditcard)
-        cc_type     = CARD_TYPE[creditcard.brand]
-        exp_date_yr = creditcard.year.to_s[2..3]
-        exp_date_mo = '%02d' % creditcard.month.to_i
-        exp_date    = exp_date_mo + exp_date_yr
-
-        card_info = {
-          'type'              => cc_type,
-          'number'            => creditcard.number,
-          'expDate'           => exp_date,
-          'cardValidationNum' => creditcard.verification_value
+      def commit(kind, request)
+        parsed = parse(kind, ssl_post(url, request, headers))
+
+        options = {
+          authorization: authorization_from(kind, parsed),
+          test: test?,
+          :avs_result => { :code => AVS_RESPONSE_CODE[parsed[:fraudResult_avsResult]] },
+          :cvv_result => parsed[:fraudResult_cardValidationResult]
         }
 
-        hash['card'] = card_info
-        hash
+        Response.new(success_from(kind, parsed), parsed[:message], parsed, options)
       end
 
-      def create_capture_hash(money, authorization, options={})
-        hash               = create_hash(money, options)
-        hash['partial']    = true if money
-        hash['litleTxnId'] = authorization
-        hash
+      def success_from(kind, parsed)
+        return (parsed[:response] == '000') unless kind == :registerToken
+        %w(000 801 802).include?(parsed[:response])
       end
 
-      def create_token_hash(creditcard_or_paypage_registration_id, options)
-        hash                  = create_hash(0, options)
-
-        if creditcard_or_paypage_registration_id.is_a?(String)
-          hash['paypageRegistrationId'] = creditcard_or_paypage_registration_id
-        else
-          hash['accountNumber'] = creditcard_or_paypage_registration_id.number
-        end
-
-        hash
+      def authorization_from(kind, parsed)
+        (kind == :registerToken) ? parsed[:litleToken] : "#{parsed[:litleTxnId]};#{kind}"
       end
 
-      def create_void_hash(identification, options)
-        hash               = create_hash(nil, options)
-        hash['litleTxnId'] = identification
-        hash
+      def split_authorization(authorization)
+        transaction_id, kind = authorization.to_s.split(';')
+        [transaction_id, kind]
       end
 
-      def create_auth_reversal_hash(identification, money, options)
-        hash               = create_hash(money, options)
-        hash['litleTxnId'] = identification
-        hash
+      def transaction_attributes(options)
+        attributes = {}
+        attributes[:id] = truncated(options[:id] || options[:order_id])
+        attributes[:reportGroup] = options[:merchant] || 'Default Report Group'
+        attributes[:customerId] = options[:customer]
+        attributes.delete_if { |key, value| value == nil }
+        attributes
       end
 
-      def create_hash(money, options)
-        fraud_check_type = {}
-        if options[:ip]
-          fraud_check_type['customerIpAddress'] = options[:ip]
-        end
-
-        enhanced_data = {}
-        if options[:invoice]
-          enhanced_data['invoiceReferenceNumber'] = options[:invoice]
-        end
-
-        if options[:description]
-          enhanced_data['customerReference'] = options[:description][0..16]
-        end
+      def root_attributes
+        {
+          merchantId: @options[:merchant_id],
+          version: SCHEMA_VERSION,
+          xmlns: "http://www.litle.com/schema"
+        }
+      end
 
-        if options[:billing_address]
-          bill_to_address = {
-            'name'         => options[:billing_address][:name],
-            'companyName'  => options[:billing_address][:company],
-            'addressLine1' => options[:billing_address][:address1],
-            'addressLine2' => options[:billing_address][:address2],
-            'city'         => options[:billing_address][:city],
-            'state'        => options[:billing_address][:state],
-            'zip'          => options[:billing_address][:zip],
-            'country'      => options[:billing_address][:country],
-            'email'        => options[:email],
-            'phone'        => options[:billing_address][:phone]
-          }
+      def build_xml_request
+        builder = Nokogiri::XML::Builder.new
+        builder.__send__('litleOnlineRequest', root_attributes) do |doc|
+          yield(doc)
         end
-        if options[:shipping_address]
-          ship_to_address = {
-            'name'         => options[:shipping_address][:name],
-            'companyName'  => options[:shipping_address][:company],
-            'addressLine1' => options[:shipping_address][:address1],
-            'addressLine2' => options[:shipping_address][:address2],
-            'city'         => options[:shipping_address][:city],
-            'state'        => options[:shipping_address][:state],
-            'zip'          => options[:shipping_address][:zip],
-            'country'      => options[:shipping_address][:country],
-            'email'        => options[:email],
-            'phone'        => options[:shipping_address][:phone]
-          }
-        end
-
-        hash = {
-          'billToAddress'  => bill_to_address,
-          'shipToAddress'  => ship_to_address,
-          'orderId'        => truncated_order_id(options),
-          'customerId'     => options[:customer],
-          'reportGroup'    => (options[:merchant] || @options[:merchant]),
-          'merchantId'     => (options[:merchant_id] || @options[:merchant_id]),
-          'orderSource'    => (options[:order_source] || 'ecommerce'),
-          'enhancedData'   => enhanced_data,
-          'fraudCheckType' => fraud_check_type,
-          'user'           => (options[:user] || @options[:user]),
-          'password'       => (options[:password] || @options[:password]),
-          'version'        => (options[:version] || @options[:version]),
-          'url'            => (options[:url] || url),
-          'proxy_addr'     => (options[:proxy_addr] || @options[:proxy_addr]),
-          'proxy_port'     => (options[:proxy_port] || @options[:proxy_port]),
-          'id'             => (options[:id] || options[:order_id] || @options[:order_id])
-        }
+        builder.doc.root.to_xml
+      end
 
-        hash.merge!('amount' => money) if(money && (money != ""))
+      def url
+        test? ? test_url : live_url
+      end
 
-        hash
+      def truncated(value)
+        return unless value
+        value[0..24]
       end
 
       def truncated_order_id(options)
-        order_id = options[:order_id] || @options[:order_id]
-        return unless order_id
-        order_id[0..24]
+        return unless options[:order_id]
+        options[:order_id][0..24]
       end
 
-      def fraud_result(authorization_response)
-        if result = authorization_response['fraudResult']
-          if result.key?('cardValidationResult')
-            cvv_to_pass = result['cardValidationResult'].blank? ? "P" : result['cardValidationResult']
-          end
-
-          avs_to_pass = AVS_RESPONSE_CODE[result['avsResult']] unless result['avsResult'].blank?
-        end
-        { 'cvv' => cvv_to_pass, 'avs' => avs_to_pass }
+      def truncated_id(options)
+        return unless options[:id]
+        options[:id][0..24]
       end
 
-      # A +LitleCardToken+ object represents a tokenized credit card, and is capable of validating the various
-      # data associated with these.
-      #
-      # == Example Usage
-      #   token = LitleCardToken.new(
-      #     :token              => '1234567890123456',
-      #     :month              => '9',
-      #     :year               => '2010',
-      #     :brand              => 'visa',
-      #     :verification_value => '123'
-      #   )
-      #
-      #   token.valid? # => true
-      #   cc.exp_date # => 0910
-      #
-      class LitleCardToken
-        include Validateable
-
-        # Returns or sets the token. (required)
-        #
-        # @return [String]
-        attr_accessor :token
-
-        # Returns or sets the expiry month for the card associated with token. (optional)
-        #
-        # @return [Integer]
-        attr_accessor :month
-
-        # Returns or sets the expiry year for the card associated with token. (optional)
-        #
-        # @return [Integer]
-        attr_accessor :year
-
-        # Returns or sets the card verification value. (optional)
-        #
-        # @return [String] the verification value
-        attr_accessor :verification_value
-
-        # Returns or sets the credit card brand. (optional)
-        #
-        # Valid card types are
-        #
-        # * +'visa'+
-        # * +'master'+
-        # * +'discover'+
-        # * +'american_express'+
-        # * +'diners_club'+
-        # * +'jcb'+
-        # * +'switch'+
-        # * +'solo'+
-        # * +'dankort'+
-        # * +'maestro'+
-        # * +'forbrugsforeningen'+
-        # * +'laser'+
-        #
-        # @return (String) the credit card brand
-        attr_accessor :brand
-
-        # Returns the Litle credit card type identifier.
-        #
-        # @return (String) the credit card type identifier
-        def type
-          CARD_TYPE[brand] unless brand.blank?
-        end
-
-        # Returns true if the expiration date is set.
-        #
-        # @return (Boolean)
-        def exp_date?
-          !month.to_i.zero? && !year.to_i.zero?
-        end
-
-        # Returns the card token expiration date in MMYY format.
-        #
-        # @return (String) the expiration date in MMYY format
-        def exp_date
-          result = ''
-          if exp_date?
-            exp_date_yr = year.to_s[2..3]
-            exp_date_mo = '%02d' % month.to_i
-
-            result = exp_date_mo + exp_date_yr
-          end
-          result
-        end
-
-        # Validates the card token details.
-        #
-        # Any validation errors are added to the {#errors} attribute.
-        def validate
-          validate_card_token
-          validate_expiration_date
-          validate_card_brand
-        end
-
-        def check?
-          false
-        end
-
-        private
-
-        CARD_TYPE = {
-            'visa'             => 'VI',
-            'master'           => 'MC',
-            'american_express' => 'AX',
-            'discover'         => 'DI',
-            'jcb'              => 'DI',
-            'diners_club'      => 'DI'
+      def headers
+        {
+          'Content-Type' => 'text/xml'
         }
-
-        def before_validate #:nodoc:
-          self.month = month.to_i
-          self.year  = year.to_i
-        end
-
-        # Litle XML Reference Guide 1.8.2
-        #
-        # The length of the original card number is reflected in the token, so a
-        # submitted 16-digit number results in a 16-digit token. Also, all tokens
-        # use only numeric characters, so you do not have to change your
-        # systems to accept alpha-numeric characters.
-        #
-        # The credit card token numbers themselves have two parts.
-        # The last four digits match the last four digits of the card number.
-        # The remaining digits (length can vary based upon original card number
-        # length) are a randomly generated.
-        def validate_card_token #:nodoc:
-          if token.to_s.length < 12 || token.to_s.match(/\A\d+\Z/).nil?
-            errors.add :token, "is not a valid card token"
-          end
-        end
-
-        def validate_expiration_date #:nodoc:
-          if !month.to_i.zero? || !year.to_i.zero?
-            errors.add :month, "is not a valid month" unless valid_month?(month)
-            errors.add :year, "is not a valid year" unless valid_expiry_year?(year)
-          end
-        end
-
-        def validate_card_brand #:nodoc:
-          errors.add :brand, "is invalid" unless brand.blank? || CreditCard.card_companies.keys.include?(brand)
-        end
-
-        def valid_month?(month)
-          (1..12).include?(month.to_i)
-        end
-
-        def valid_expiry_year?(year)
-          year.to_s =~ /\A\d{4}\Z/ && year.to_i > 1987
-        end
       end
+
     end
   end
 end