activemerchant 1.100.0 → 1.133.0

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

@@ -8,10 +8,10 @@ module ActiveMerchant #:nodoc:
       # Currently Authorization and Capture is not implemented because
       # capturing requires the original credit card information
       TRANSACTIONS = {
-        :purchase       => 'PURCHASE',
-        :authorization  => 'AUTHORISE',
-        :capture        => 'ADVICE',
-        :credit         => 'REFUND'
+        purchase: 'PURCHASE',
+        authorization: 'AUTHORISE',
+        capture: 'ADVICE',
+        credit: 'REFUND'
       }
 
       SUCCESS = 'Accepted'
@@ -20,7 +20,7 @@ module ActiveMerchant #:nodoc:
       self.supported_countries = ['AU']
       self.homepage_url = 'http://www.commsecure.com.au/paysecure.shtml'
       self.display_name = 'PaySecure'
-      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
+      self.supported_cardtypes = %i[visa master american_express diners_club]
 
       def initialize(options = {})
         requires!(options, :login, :password)
@@ -43,7 +43,7 @@ module ActiveMerchant #:nodoc:
       # Used for capturing, which is currently not supported.
       def add_reference(post, identification)
         auth, trans_id = identification.split(';')
-        post[:authnum]    = auth
+        post[:authnum] = auth
         post[:transid] = trans_id
       end
 
@@ -69,9 +69,8 @@ module ActiveMerchant #:nodoc:
         response = parse(ssl_post(self.live_url, post_data(action, parameters)))
 
         Response.new(successful?(response), message_from(response), response,
-          :test => test_response?(response),
-          :authorization => authorization_from(response)
-        )
+          test: test_response?(response),
+          authorization: authorization_from(response))
       end
 
       def successful?(response)
@@ -79,7 +78,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorization_from(response)
-        [ response[:authnum], response[:transid] ].compact.join(';')
+        [response[:authnum], response[:transid]].compact.join(';')
       end
 
       def test_response?(response)
@@ -104,7 +103,7 @@ module ActiveMerchant #:nodoc:
         parameters[:merchant_id]      = @options[:login]
         parameters[:password]         = @options[:password]
 
-        parameters.reject { |k, v| v.blank? }.collect { |key, value| "#{key.to_s.upcase}=#{CGI.escape(value.to_s)}" }.join('&')
+        parameters.reject { |_k, v| v.blank? }.collect { |key, value| "#{key.to_s.upcase}=#{CGI.escape(value.to_s)}" }.join('&')
       end
     end
   end

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

@@ -0,0 +1,450 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayTraceGateway < Gateway
+      self.test_url = 'https://api.paytrace.com'
+      self.live_url = 'https://api.paytrace.com'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'https://paytrace.com/'
+      self.display_name = 'PayTrace'
+
+      # Response codes based on API Response Codes found here: https://developers.paytrace.com/support/home#14000041297
+      STANDARD_ERROR_CODE_MAPPING = {
+        '1'   => STANDARD_ERROR_CODE[:error_occurred],
+        '102' => STANDARD_ERROR_CODE[:declined],
+        '103' => STANDARD_ERROR_CODE[:auto_voided],
+        '107' => STANDARD_ERROR_CODE[:unsuccessful_refund],
+        '108' => STANDARD_ERROR_CODE[:test_refund],
+        '110' => STANDARD_ERROR_CODE[:unsuccessful_void],
+        '113' => STANDARD_ERROR_CODE[:unsuccessful_capture]
+      }
+
+      ENDPOINTS = {
+        customer_id_sale: 'transactions/sale/by_customer',
+        keyed_sale: 'transactions/sale/keyed',
+        customer_id_auth: 'transactions/authorization/by_customer',
+        keyed_auth: 'transactions/authorization/keyed',
+        capture: 'transactions/authorization/capture',
+        transaction_refund: 'transactions/refund/for_transaction',
+        transaction_void: 'transactions/void',
+        store: 'customer/create',
+        redact: 'customer/delete',
+        level_3_visa: 'level_three/visa',
+        level_3_mastercard: 'level_three/mastercard',
+        ach_sale: 'checks/sale/by_account',
+        ach_customer_sale: 'checks/sale/by_customer',
+        ach_authorize: 'checks/hold/by_account',
+        ach_customer_authorize: 'checks/hold/by_customer',
+        ach_refund: 'checks/refund/by_transaction',
+        ach_capture: 'checks/manage/fund',
+        ach_void: 'checks/manage/void'
+      }
+
+      def initialize(options = {})
+        requires!(options, :username, :password, :integrator_id)
+        super
+        acquire_access_token
+      end
+
+      def purchase(money, payment_or_customer_id, options = {})
+        if visa_or_mastercard?(options)
+          MultiResponse.run(:use_first_response) do |r|
+            endpoint = customer_id?(payment_or_customer_id) ? ENDPOINTS[:customer_id_sale] : ENDPOINTS[:keyed_sale]
+
+            r.process { commit(endpoint, build_purchase_request(money, payment_or_customer_id, options)) }
+            r.process { commit(ENDPOINTS[:"level_3_#{options[:visa_or_mastercard]}"], send_level_3_data(r, options)) }
+          end
+        else
+          post = build_purchase_request(money, payment_or_customer_id, options)
+          endpoint = if payment_or_customer_id.kind_of?(Check)
+                       ENDPOINTS[:ach_sale]
+                     elsif options[:check_transaction]
+                       ENDPOINTS[:ach_customer_sale]
+                     elsif post[:customer_id]
+                       ENDPOINTS[:customer_id_sale]
+                     else
+                       ENDPOINTS[:keyed_sale]
+                     end
+          response = commit(endpoint, post)
+          check_token_response(response, endpoint, post, options)
+        end
+      end
+
+      def authorize(money, payment_or_customer_id, options = {})
+        post = {}
+        add_amount(post, money, options)
+        if customer_id?(payment_or_customer_id)
+          post[:customer_id] = payment_or_customer_id
+          endpoint = if options[:check_transaction]
+                       ENDPOINTS[:ach_customer_authorize]
+                     else
+                       ENDPOINTS[:customer_id_auth]
+                     end
+        else
+          add_payment(post, payment_or_customer_id)
+          add_address(post, payment_or_customer_id, options)
+          add_customer_data(post, options)
+          endpoint = payment_or_customer_id.kind_of?(Check) ? ENDPOINTS[:ach_authorize] : ENDPOINTS[:keyed_auth]
+        end
+        response = commit(endpoint, post)
+        check_token_response(response, endpoint, post, options)
+      end
+
+      def capture(money, authorization, options = {})
+        if visa_or_mastercard?(options)
+          MultiResponse.run do |r|
+            r.process { commit(ENDPOINTS[:capture], build_capture_request(money, authorization, options)) }
+            r.process { commit(ENDPOINTS[:"level_3_#{options[:visa_or_mastercard]}"], send_level_3_data(r, options)) }
+          end
+        else
+          post = build_capture_request(money, authorization, options)
+          endpoint = if options[:check_transaction]
+                       ENDPOINTS[:ach_capture]
+                     else
+                       ENDPOINTS[:capture]
+                     end
+          response = commit(endpoint, post)
+          check_token_response(response, endpoint, post, options)
+        end
+      end
+
+      def refund(money, authorization, options = {})
+        # currently only support full and partial refunds of settled transactions via a transaction ID
+        post = {}
+        add_amount(post, money, options)
+        if options[:check_transaction]
+          post[:check_transaction_id] = authorization
+          endpoint = ENDPOINTS[:ach_refund]
+        else
+          post[:transaction_id] = authorization
+          endpoint = ENDPOINTS[:transaction_refund]
+        end
+        response = commit(endpoint, post)
+        check_token_response(response, endpoint, post, options)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        if options[:check_transaction]
+          post[:check_transaction_id] = authorization
+          endpoint = ENDPOINTS[:ach_void]
+        else
+          post[:transaction_id] = authorization
+          endpoint = ENDPOINTS[:transaction_void]
+        end
+
+        response = commit(endpoint, post)
+        check_token_response(response, endpoint, post, options)
+      end
+
+      def verify(credit_card, options = {})
+        authorize(0, credit_card, options)
+      end
+
+      # The customer_IDs that come from storing cards can be used for auth and purchase transaction types
+      def store(credit_card, options = {})
+        post = {}
+        post[:customer_id] = options[:customer_id] || SecureRandom.hex(12)
+        add_payment(post, credit_card)
+        add_address(post, credit_card, options)
+        response = commit(ENDPOINTS[:store], post)
+        check_token_response(response, ENDPOINTS[:store], post, options)
+      end
+
+      def unstore(customer_id)
+        post = {}
+        post[:customer_id] = customer_id
+        response = commit(ENDPOINTS[:redact], post)
+        check_token_response(response, ENDPOINTS[:redact], post, options)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Bearer )[a-zA-Z0-9:_]+), '\1[FILTERED]').
+          gsub(%r(("credit_card\\?":{\\?"number\\?":\\?")\d+), '\1[FILTERED]').
+          gsub(%r(("cvv\\?":\\?")\d+), '\1[FILTERED]').
+          gsub(%r(("username\\?":\\?")\w+@+\w+.+\w+), '\1[FILTERED]').
+          gsub(%r(("password\\?":\\?")\w+), '\1[FILTERED]').
+          gsub(%r(("integrator_id\\?":\\?")\w+), '\1[FILTERED]')
+      end
+
+      def acquire_access_token
+        post = {}
+        post[:grant_type] = 'password'
+        post[:username] = @options[:username]
+        post[:password] = @options[:password]
+        data = post.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+        url = live_url + '/oauth/token'
+        oauth_headers = {
+          'Accept'            => '*/*',
+          'Content-Type'      => 'application/x-www-form-urlencoded'
+        }
+        response = ssl_post(url, data, oauth_headers)
+        json_response = JSON.parse(response)
+
+        @options[:access_token] = json_response['access_token'] if json_response['access_token']
+        response
+      end
+
+      private
+
+      def build_purchase_request(money, payment_or_customer_id, options)
+        post = {}
+        add_amount(post, money, options)
+        if customer_id?(payment_or_customer_id)
+          post[:customer_id] = payment_or_customer_id
+        else
+          add_payment(post, payment_or_customer_id)
+          add_address(post, payment_or_customer_id, options)
+          add_customer_data(post, options)
+        end
+
+        post
+      end
+
+      def build_capture_request(money, authorization, options)
+        post = {}
+        if options[:check_transaction]
+          post[:check_transaction_id] = authorization
+        else
+          post[:transaction_id] = authorization
+        end
+        add_amount(post, money, options)
+
+        post
+      end
+
+      # method can only be used to add level 3 data to any approved and unsettled sale transaction so it is built into the standard purchase workflow above
+      def send_level_3_data(response, options)
+        post = {}
+        post[:transaction_id] = response.authorization
+        add_level_3_data(post, options)
+
+        post
+      end
+
+      def visa_or_mastercard?(options)
+        return false unless options[:visa_or_mastercard]
+
+        options[:visa_or_mastercard] == 'visa' || options[:visa_or_mastercard] == 'mastercard'
+      end
+
+      def customer_id?(payment_or_customer_id)
+        payment_or_customer_id.class == String
+      end
+
+      def string_literal_to_boolean(value)
+        return value unless value.class == String
+
+        if value.casecmp('true').zero?
+          true
+        elsif value.casecmp('false').zero?
+          false
+        else return nil
+        end
+      end
+
+      def add_customer_data(post, options)
+        return unless options[:email]
+
+        post[:email] = options[:email]
+      end
+
+      def add_address(post, creditcard, options)
+        return unless options[:billing_address] || options[:address]
+
+        address = options[:billing_address] || options[:address]
+        post[:billing_address] = {}
+        post[:billing_address][:name] = creditcard.name
+        post[:billing_address][:street_address] = address[:address1]
+        post[:billing_address][:city] = address[:city]
+        post[:billing_address][:state] = address[:state]
+        post[:billing_address][:zip] = address[:zip]
+      end
+
+      def add_amount(post, money, options)
+        post[:amount] = amount(money)
+      end
+
+      def add_payment(post, payment)
+        if payment.kind_of?(Check)
+          post[:check] = {}
+          post[:check][:account_number] = payment.account_number
+          post[:check][:routing_number] = payment.routing_number
+        else
+          post[:credit_card] = {}
+          post[:credit_card][:number] = payment.number
+          post[:credit_card][:expiration_month] = payment.month
+          post[:credit_card][:expiration_year] = payment.year
+        end
+      end
+
+      def add_level_3_data(post, options)
+        post[:invoice_id] = options[:invoice_id] if options[:invoice_id]
+        post[:customer_reference_id] = options[:customer_reference_id] if options[:customer_reference_id]
+        post[:tax_amount] = options[:tax_amount].to_i if options[:tax_amount]
+        post[:national_tax_amount] = options[:national_tax_amount].to_i if options[:national_tax_amount]
+        post[:merchant_tax_id] = options[:merchant_tax_id] if options[:merchant_tax_id]
+        post[:customer_tax_id] = options[:customer_tax_id] if options[:customer_tax_id]
+        post[:commodity_code] = options[:commodity_code] if options[:commodity_code]
+        post[:discount_amount] = options[:discount_amount].to_i if options[:discount_amount]
+        post[:freight_amount] = options[:freight_amount].to_i if options[:freight_amount]
+        post[:duty_amount] = options[:duty_amount].to_i if options[:duty_amount]
+        post[:additional_tax_amount] = options[:additional_tax_amount].to_i if options[:additional_tax_amount]
+        post[:additional_tax_rate] = options[:additional_tax_rate].to_i if options[:additional_tax_rate]
+
+        add_source_address(post, options)
+        add_shipping_address(post, options)
+        add_line_items(post, options)
+      end
+
+      def add_source_address(post, options)
+        return unless source_address =  options[:source_address] ||
+                                        options[:billing_address] ||
+                                        options[:address]
+
+        post[:source_address] = {}
+        post[:source_address][:zip] = source_address[:zip] if source_address[:zip]
+      end
+
+      def add_shipping_address(post, options)
+        return unless shipping_address = options[:shipping_address]
+
+        post[:shipping_address] = {}
+        post[:shipping_address][:name] = shipping_address[:name] if shipping_address[:name]
+        post[:shipping_address][:street_address] = shipping_address[:address1] if shipping_address[:address1]
+        post[:shipping_address][:street_address2] = shipping_address[:address2] if shipping_address[:address2]
+        post[:shipping_address][:city] = shipping_address[:city] if shipping_address[:city]
+        post[:shipping_address][:state] = shipping_address[:state] if shipping_address[:state]
+        post[:shipping_address][:zip] = shipping_address[:zip] if shipping_address[:zip]
+        post[:shipping_address][:country] = shipping_address[:country] if shipping_address[:country]
+      end
+
+      def add_line_items(post, options)
+        return unless options[:line_items]
+
+        line_items = []
+        options[:line_items].each do |li|
+          obj = {}
+
+          obj[:additional_tax_amount] = li[:additional_tax_amount].to_i if li[:additional_tax_amount]
+          obj[:additional_tax_included] = string_literal_to_boolean(li[:additional_tax_included]) if li[:additional_tax_included]
+          obj[:additional_tax_rate] = li[:additional_tax_rate].to_i if li[:additional_tax_rate]
+          obj[:amount] = li[:amount].to_i if li[:amount]
+          obj[:commodity_code] = li[:commodity_code] if li[:commodity_code]
+          obj[:debit_or_credit] = li[:debit_or_credit] if li[:debit_or_credit]
+          obj[:description] = li[:description] if li[:description]
+          obj[:discount_amount] = li[:discount_amount].to_i if li[:discount_amount]
+          obj[:discount_rate] = li[:discount_rate].to_i if li[:discount_rate]
+          obj[:discount_included] = string_literal_to_boolean(li[:discount_included]) if li[:discount_included]
+          obj[:merchant_tax_id] = li[:merchant_tax_id] if li[:merchant_tax_id]
+          obj[:product_id] = li[:product_id] if li[:product_id]
+          obj[:quantity] = li[:quantity] if li[:quantity]
+          obj[:transaction_id] = li[:transaction_id] if li[:transaction_id]
+          obj[:tax_included] = string_literal_to_boolean(li[:tax_included]) if li[:tax_included]
+          obj[:unit_of_measure] = li[:unit_of_measure] if li[:unit_of_measure]
+          obj[:unit_cost] = li[:unit_cost].to_i if li[:unit_cost]
+
+          line_items << obj
+        end
+        post[:line_items] = line_items
+      end
+
+      def check_token_response(response, endpoint, body = {}, options = {})
+        return response unless response.params['error'] == 'invalid_token'
+
+        acquire_access_token
+        commit(endpoint, body)
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(action, parameters)
+        base_url = (test? ? test_url : live_url)
+        url = base_url + '/v1/' + action
+        raw_response = ssl_post(url, post_data(parameters), headers)
+        response = parse(raw_response)
+        success = success_from(response)
+
+        Response.new(
+          success,
+          message_from(success, response),
+          response,
+          authorization: authorization_from(action, response),
+          avs_result: AVSResult.new(code: response['avs_response']),
+          cvv_result: response['csc_response'],
+          test: test?,
+          error_code: success ? nil : error_code_from(response)
+        )
+      rescue JSON::ParserError
+        unparsable_response(raw_response)
+      end
+
+      def unparsable_response(raw_response)
+        message = 'Unparsable response received from PayTrace. Please contact PayTrace if you continue to receive this message.'
+        message += " (The raw response returned by the API was #{raw_response.inspect})"
+        return Response.new(false, message)
+      end
+
+      def headers
+        {
+          'Content-type' => 'application/json',
+          'Authorization' => 'Bearer ' + @options[:access_token]
+        }
+      end
+
+      def success_from(response)
+        response['success']
+      end
+
+      def message_from(success, response)
+        return response['status_message'] if success
+
+        if error = response['errors']
+          message = 'Errors-'
+          error.each do |k, v|
+            message.concat(" code:#{k}, message:#{v}")
+          end
+        else
+          message = response['status_message'].to_s + " #{response['approval_message']}"
+        end
+
+        message
+      end
+
+      # store transactions do not return a transaction_id, but they return a customer_id that will then be used as the third_party_token for the stored payment method
+      def authorization_from(action, response)
+        if action == ENDPOINTS[:store]
+          response['customer_id']
+        else
+          response['transaction_id'] || response['check_transaction_id']
+        end
+      end
+
+      def post_data(parameters = {})
+        parameters[:password] = @options[:password]
+        parameters[:username] = @options[:username]
+        parameters[:integrator_id] = @options[:integrator_id]
+
+        parameters.to_json
+      end
+
+      def error_code_from(response)
+        STANDARD_ERROR_CODE_MAPPING[response['response_code']]
+      end
+
+      def handle_response(response)
+        response.body
+      end
+    end
+  end
+end

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

@@ -12,34 +12,34 @@ module ActiveMerchant #:nodoc:
 
       # Transactions hash
       TRANSACTIONS = {
-        :authorization => '00001',
-        :capture => '00002',
-        :purchase => '00003',
-        :unreferenced_credit => '00004',
-        :void => '00005',
-        :refund => '00014'
+        authorization: '00001',
+        capture: '00002',
+        purchase: '00003',
+        unreferenced_credit: '00004',
+        void: '00005',
+        refund: '00014'
       }
 
       CURRENCY_CODES = {
-        'AUD'=> '036',
-        'CAD'=> '124',
-        'CZK'=> '203',
-        'DKK'=> '208',
-        'HKD'=> '344',
-        'ICK'=> '352',
-        'JPY'=> '392',
-        'NOK'=> '578',
-        'SGD'=> '702',
-        'SEK'=> '752',
-        'CHF'=> '756',
-        'GBP'=> '826',
-        'USD'=> '840',
-        'EUR'=> '978',
-        'XPF'=> '953'
+        'AUD' => '036',
+        'CAD' => '124',
+        'CZK' => '203',
+        'DKK' => '208',
+        'HKD' => '344',
+        'ICK' => '352',
+        'JPY' => '392',
+        'NOK' => '578',
+        'SGD' => '702',
+        'SEK' => '752',
+        'CHF' => '756',
+        'GBP' => '826',
+        'USD' => '840',
+        'EUR' => '978',
+        'XPF' => '953'
       }
 
       SUCCESS_CODES = ['00000']
-      UNAVAILABILITY_CODES = ['00001', '00097', '00098']
+      UNAVAILABILITY_CODES = %w[00001 00097 00098]
       SUCCESS_MESSAGE = 'The transaction was approved'
       FAILURE_MESSAGE = 'The transaction failed'
 
@@ -51,7 +51,7 @@ module ActiveMerchant #:nodoc:
       self.supported_countries = ['FR']
 
       # The card types supported by the payment gateway
-      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb]
+      self.supported_cardtypes = %i[visa master american_express diners_club jcb]
 
       # The homepage URL of the gateway
       self.homepage_url = 'http://www.paybox.com/'
@@ -64,10 +64,31 @@ module ActiveMerchant #:nodoc:
         super
       end
 
+      def add_3dsecure(post, options)
+        # ECI=02 => MasterCard success
+        # ECI=05 => Visa, Amex or JCB success
+        if options[:eci] == '02' || options[:eci] == '05'
+          post[:"3DSTATUS"] = 'Y'
+          post[:"3DENROLLED"] = 'Y'
+          post[:"3DSIGNVAL"] = 'Y'
+          post[:"3DERROR"] = '0'
+        else
+          post[:"3DSTATUS"] = 'N'
+          post[:"3DENROLLED"] = 'N'
+          post[:"3DSIGNVAL"] = 'N'
+          post[:"3DERROR"] = '10000'
+        end
+        post[:"3DECI"] = options[:eci]
+        post[:"3DXID"] = options[:xid]
+        post[:"3DCAVV"] = options[:cavv]
+        post[:"3DCAVVALGO"] = options[:cavv_algorithm]
+      end
+
       def authorize(money, creditcard, options = {})
         post = {}
         add_invoice(post, options)
         add_creditcard(post, creditcard)
+        add_3dsecure(post, options[:three_d_secure]) if options[:three_d_secure]
         add_amount(post, money, options)
 
         commit('authorization', money, post)
@@ -77,6 +98,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_invoice(post, options)
         add_creditcard(post, creditcard)
+        add_3dsecure(post, options[:three_d_secure]) if options[:three_d_secure]
         add_amount(post, money, options)
 
         commit('purchase', money, post)
@@ -95,7 +117,7 @@ module ActiveMerchant #:nodoc:
 
       def void(identification, options = {})
         requires!(options, :order_id, :amount)
-        post ={}
+        post = {}
         add_invoice(post, options)
         add_reference(post, identification)
         add_amount(post, options[:amount], options)
@@ -153,12 +175,14 @@ module ActiveMerchant #:nodoc:
         request_data = post_data(action, parameters)
         response = parse(ssl_post(test? ? self.test_url : self.live_url, request_data))
         response = parse(ssl_post(self.live_url_backup, request_data)) if service_unavailable?(response) && !test?
-        Response.new(success?(response), message_from(response), response.merge(
-          :timestamp => parameters[:dateq]),
-          :test => test?,
-          :authorization => response[:numappel].to_s + response[:numtrans].to_s,
-          :fraud_review => false,
-          :sent_params => parameters.delete_if { |key, value| ['porteur', 'dateval', 'cvv'].include?(key.to_s) }
+        Response.new(
+          success?(response),
+          message_from(response),
+          response.merge(timestamp: parameters[:dateq]),
+          test: test?,
+          authorization: response[:numappel].to_s + response[:numtrans].to_s,
+          fraud_review: false,
+          sent_params: parameters.delete_if { |key, _value| %w[porteur dateval cvv].include?(key.to_s) }
         )
       end
 
@@ -171,20 +195,20 @@ module ActiveMerchant #:nodoc:
       end
 
       def message_from(response)
-        success?(response) ? SUCCESS_MESSAGE : (response[:commentaire]  || FAILURE_MESSAGE)
+        success?(response) ? SUCCESS_MESSAGE : (response[:commentaire] || FAILURE_MESSAGE)
       end
 
       def post_data(action, parameters = {})
         parameters.update(
-          :version => API_VERSION,
-          :type => TRANSACTIONS[action.to_sym],
-          :dateq => Time.now.strftime('%d%m%Y%H%M%S'),
-          :numquestion => unique_id(parameters[:order_id]),
-          :site => @options[:login].to_s[0, 7],
-          :rang => @options[:rang] || @options[:login].to_s[7..-1],
-          :cle => @options[:password],
-          :pays => '',
-          :archivage => parameters[:order_id]
+          version: API_VERSION,
+          type: TRANSACTIONS[action.to_sym],
+          dateq: Time.now.strftime('%d%m%Y%H%M%S'),
+          numquestion: unique_id(parameters[:order_id]),
+          site: @options[:login].to_s[0, 7],
+          rang: @options[:rang] || @options[:login].to_s[7..-1],
+          cle: @options[:password],
+          pays: '',
+          archivage: parameters[:order_id]
         )
 
         parameters.collect { |key, value| "#{key.to_s.upcase}=#{CGI.escape(value.to_s)}" }.join('&')