activemerchant_paybox_direct_plus 0.2.0 → 1.0.0

data/lib/activemerchant_paybox_direct_plus.rb

@@ -2,220 +2,140 @@ require 'active_merchant'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-    class PayboxDirectPlusGateway < Gateway
-      TEST_URL = 'https://preprod-ppps.paybox.com/PPPS.php'
-      TEST_URL_BACKUP = 'https://preprod-ppps.paybox.com/PPPS.php'
-      LIVE_URL = 'https://ppps.paybox.com/PPPS.php'
-      LIVE_URL_BACKUP = 'https://ppps1.paybox.com/PPPS.php'
-
+    class PayboxDirectPlusGateway < PayboxDirectGateway
       # Payment API Version
       API_VERSION = '00104'
 
       # Transactions hash
       TRANSACTIONS = {
-        :subscriber_authorization => '00051',
-        :subscriber_capture => '00052',
-        :subscriber_purchase => '00053',
-        :subscriber_credit => '00054',
-        :subscriber_void => '00055',
-        :subscriber_create => '00056',
-        :subscriber_update => '00057',
-        :subscriber_destroy => '00058',
-      }
-
-      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'
+        authorization:            '00001',
+        capture:                  '00002',
+        purchase:                 '00003',
+        unreferenced_credit:      '00004',
+        void:                     '00005',
+        refund:                   '00014',
+        subscriber_authorization: '00051',
+        subscriber_capture:       '00052',
+        subscriber_purchase:      '00053',
+        subscriber_credit:        '00054',
+        subscriber_refund:        '00014',
+        subscriber_void:          '00055',
+        subscriber_create:        '00056',
+        subscriber_update:        '00057',
+        subscriber_destroy:       '00058'
       }
 
       ALREADY_EXISTING_PROFILE_CODES = ['00016']
       UNKNOWN_PROFILE_CODES = ['00017']
-      SUCCESS_CODES = ['00000']
-      UNAVAILABILITY_CODES = ['00001', '00097', '00098']
-      FRAUD_CODES = ['00102','00104','00105','00134','00138','00141','00143','00156','00157','00159']
-      SUCCESS_MESSAGE = 'The transaction was approved'
-      FAILURE_MESSAGE = 'The transaction failed'
-
-      # Money is referenced in cents
-      self.money_format = :cents
-      self.default_currency = 'EUR'
-
-      # The countries the gateway supports merchants from as 2 digit ISO country codes
-      self.supported_countries = ['FR']
-
-      # The card types supported by the payment gateway
-      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb]
-
-      # The homepage URL of the gateway
-      self.homepage_url = 'http://www.paybox.com/'
+      FRAUD_CODES = %w(00102 00104 00105 00134 00138 00141 00143 00156 00157 00159)
 
       # The name of the gateway
       self.display_name = 'Paybox Direct Plus'
 
-      def initialize(options = {})
-        requires!(options, :login, :password)
-        @options = options
-        super
-      end
-
       def payment_profiles_supported?
         true
       end
 
-      def authorize(money, creditcard, options = {})
+      def subscriber_authorize(money, creditcard, options = {})
         requires!(options, :user_reference)
         post = {}
         add_invoice(post, options)
         add_creditcard(post, creditcard, options)
         add_user_reference(post, options)
+        add_amount(post, money, options)
         commit('subscriber_authorization', money, post)
       end
 
-      def purchase(money, creditcard, options = {})
+      def subscriber_purchase(money, creditcard, options = {})
         requires!(options, :credit_card_reference, :user_reference)
         post = {}
         add_invoice(post, options)
         add_creditcard(post, creditcard, options)
         add_user_reference(post, options)
+        add_amount(post, money, options)
         commit('subscriber_purchase', money, post)
       end
 
-      def capture(money, authorization, options = {})
+      def subscriber_capture(money, authorization, options = {})
         requires!(options, :order_id, :user_reference)
         post = {}
         add_invoice(post, options)
         add_reference(post, authorization)
         add_user_reference(post, options)
+        add_amount(post, money, options)
         commit('subscriber_capture', money, post)
       end
 
-      def void(money, authorization, options = {})
+      def subscriber_void(money, authorization, options = {})
         requires!(options, :order_id, :user_reference)
         post = {}
         add_invoice(post, options)
         add_reference(post, authorization)
         add_user_reference(post, options)
+        add_amount(post, money, options)
         post[:porteur] = '000000000000000'
         post[:dateval] = '0000'
         commit('subscriber_void', money, post)
       end
 
-      def credit(money, identification, options = {})
+      def subscriber_credit(money, identification, options = {})
         post = {}
         add_invoice(post, options)
         add_reference(post, identification)
         add_user_reference(post, options)
+        add_amount(post, money, options)
         commit('subscriber_credit', money, post)
       end
 
-      def create_payment_profile(money, creditcard, options = {})
+      def subscriber_refund(money, authorization, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_reference(post, authorization)
+        add_user_reference(post, options)
+        add_amount(post, money, options)
+        commit('subscriber_refund', money, post)
+      end
+
+      def subscriber_create(money, creditcard, options = {})
         requires!(options, :user_reference)
         post = {}
         add_creditcard(post, creditcard, options)
         add_user_reference(post, options)
+        add_amount(post, money, options)
         commit('subscriber_create', money, post)
       end
 
-      def update_payment_profile(money, creditcard, options = {})
+      def subscriber_update(money, creditcard, options = {})
         post = {}
         add_creditcard(post, creditcard, options)
         add_user_reference(post, options)
+        add_amount(post, money, options)
         commit('subscriber_update', money, post)
       end
 
-      def destroy_payment_profile(money, options)
+      def subscriber_destroy(money, options)
         post = {}
         add_user_reference(post, options)
+        add_amount(post, money, options)
         commit('subscriber_destroy', money, post)
       end
 
-      def test?
-        @options[:test] || Base.gateway_mode == :test
-      end
-
       private
 
-      def add_invoice(post, options)
-        post[:reference] = options[:order_id]
-      end
-
       def add_creditcard(post, creditcard, options = {})
-        post[:porteur] = options[:credit_card_reference] ? options[:credit_card_reference] : creditcard.number
+        post[:porteur] = options[:credit_card_reference] || creditcard.number
         post[:dateval] = expdate(creditcard)
         post[:cvv] = creditcard.verification_value if creditcard.verification_value?
       end
-      
+
       def add_user_reference(post, options)
         post[:refabonne] = options[:user_reference]
       end
-      
-      def add_reference(post, identification)
-        post[:numappel] = identification[0,10]
-        post[:numtrans] = identification[10,10]
-      end
-
-      def parse(body)
-        if RUBY_VERSION < "1.9"
-          require 'iconv'
-          body = Iconv.iconv("UTF-8","LATIN1", body.to_s).join
-        else
-          body.encode!('UTF-8', Encoding::ISO_8859_1)
-        end
-        results = {}
-        body.split(/&/).each do |pair|
-          key,val = pair.split(/=/)
-          results[key.downcase.to_sym] = CGI.unescape(val) if val
-        end
-        #Rails.logger.info results.inspect
-        results
-      end
-
-      def commit(action, money = nil, parameters = nil)
-        parameters[:montant] = ('0000000000' + (money ? amount(money) : ''))[-10..-1]
-        parameters[:devise] = CURRENCY_CODES[options[:currency] || currency(money)]
-        request_data = post_data(action,parameters)
-        #debugger
-        response = parse(ssl_post(test? ? TEST_URL : LIVE_URL, request_data))
-        response = parse(ssl_post(test? ? TEST_URL_BACKUP : LIVE_URL_BACKUP, request_data)) if service_unavailable?(response)
-        Response.new(success?(response), message_from(response), response.merge({
-            :timestamp => parameters[:dateq],
-            :test => test?,
-            :authorization => response[:numappel].to_s + response[:numtrans].to_s,
-            :cvv_result => '',
-            :avs_result => '',
-            :fraud_review => fraud_review?(response),
-            :unknown_customer_profile => unknown_customer_profile?(response),
-            :already_existing_customer_profile => already_existing_customer_profile?(response),
-            :credit_card_reference => response[:porteur],
-            :sent_params => parameters.delete_if{|key,value| ['porteur','dateval','cvv'].include?(key.to_s)}
-            })
-        )
-      end
-
-      def success?(response)
-        SUCCESS_CODES.include?(response[:codereponse])
-      end
 
       def fraud_review?(response)
         FRAUD_CODES.include?(response[:codereponse])
       end
 
-      def service_unavailable?(response)
-        UNAVAILABILITY_CODES.include?(response[:codereponse])
-      end
-
       def unknown_customer_profile?(response)
         UNKNOWN_PROFILE_CODES.include?(response[:codereponse])
       end
@@ -224,47 +144,21 @@ module ActiveMerchant #:nodoc:
         ALREADY_EXISTING_PROFILE_CODES.include?(response[:codereponse])
       end
 
-      def message_from(response)
-        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[:reference]),
-          :site => @options[:login].to_s[0,7],
-          :rang => @options[:login].to_s[7..-1],
-          :cle => @options[:password],
-          :pays => '',
-          :archivage => parameters[:reference]
+          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[:reference]
         )
 
-        p = parameters.collect { |key, value| "#{key.to_s.upcase}=#{CGI.escape(value.to_s)}" }.join("&")
-        #Rails.logger.info "\n***************************"
-        #Rails.logger.debug "********** POST DATA IN PAYBOX PLUS ***********"
-        #Rails.logger.debug "*** Parameters for post data:"
-        #Rails.logger.debug "#{p.inspect}"
-        #Rails.logger.info "*****************************"
-        p
-      end
-
-      def unique_id(seed = 0)
-        randkey = "#{seed.hash}#{Time.now.usec}".to_i % 2147483647 # Max paybox value for the question number
-
-        "0000000000#{randkey}"[-10..-1]
+        parameters.collect { |key, value| "#{key.to_s.upcase}=#{CGI.escape(value.to_s)}" }.join('&')
       end
-
-      def expdate(credit_card)
-        year  = sprintf("%.4i", credit_card.year)
-        month = sprintf("%.2i", credit_card.month)
-
-        "#{month}#{year[-2..-1]}"
-      end
-
     end
   end
 end
-

data/test/remote/gateways/remote_paybox_direct_plus_test.rb

@@ -1,59 +1,96 @@
 require 'test_helper'
 
-class RemotePayboxDirectPlusTest < Test::Unit::TestCase
-  
+class RemotePayboxDirectTest < Minitest::Test
   def setup
-    @gateway = PayboxDirectPlusGateway.new(fixtures(:paybox_direct_plus))
-    
+    @gateway = ActiveMerchant::Billing::PayboxDirectPlusGateway.new(
+      login:    '199988899',
+      password: '1999888I'
+    )
+
     @amount = 100
     @credit_card = credit_card('1111222233334444')
-    @declined_card = credit_card('1111222233334445')
-    
-    @options = { 
-      :order_id => "REF#{Time.now.usec}",
-      :user_reference => "USER#{Time.now.usec}"
+
+    @options = {
+      order_id:       "REF#{Time.now.usec}",
+      user_reference: "USER#{Time.now.usec}"
     }
   end
-  
+
   def test_create_profile
-    assert response = @gateway.create_payment_profile(@amount, @credit_card, @options)
-    assert_success response
+    assert response = @gateway.subscriber_create(@amount, @credit_card, @options)
+    assert response.success?
     assert_equal 'The transaction was approved', response.message
   end
-  
+
   def test_create_profile_capture_and_void
-    assert response = @gateway.create_payment_profile(@amount, @credit_card, @options)
-    assert_success response
-    
-    credit_card_reference = response.params["credit_card_reference"]
-    assert_not_nil credit_card_reference
-    
-    assert capture = @gateway.capture(@amount, response.params["authorization"], @options)
-    assert_success capture
-    
-    assert void = @gateway.void(@amount, capture.params["authorization"], @options)
+    assert response = @gateway.subscriber_create(@amount, @credit_card, @options)
+    assert response.success?
+
+    credit_card_reference = response.params['porteur']
+    assert !credit_card_reference.nil?
+
+    assert capture = @gateway.subscriber_capture(@amount, response.authorization, @options)
+    assert capture.success?
+
+    assert void = @gateway.subscriber_void(@amount, capture.authorization, @options)
     assert_equal 'The transaction was approved', void.message
-    assert_success void
+    assert void.success?
   end
-  
+
   def test_create_profile_and_purchase
-    assert response = @gateway.create_payment_profile(@amount, @credit_card, @options)
-    assert_success response
-    
-    credit_card_reference = response.params["credit_card_reference"]
-    assert_not_nil credit_card_reference
-    
+    assert response = @gateway.subscriber_create(@amount, @credit_card, @options)
+    assert response.success?
+
+    credit_card_reference = response.params['porteur']
+    assert !credit_card_reference.nil?
+
     @credit_card.number = nil
-    
-    assert_response = @gateway.purchase(@amount, @credit_card, @options.merge({ :credit_card_reference => credit_card_reference }))
-    assert_success response
-    assert_equal 'The transaction was approved', response.message
+    @credit_card.first_name = nil
+    @credit_card.last_name = nil
+
+    assert success = @gateway.subscriber_purchase(@amount, @credit_card, @options.merge(credit_card_reference: credit_card_reference))
+    assert success.success?
+    assert_equal 'The transaction was approved', success.message
   end
-  
+
+  def test_create_profile_capture_and_refund
+    assert response = @gateway.subscriber_create(@amount, @credit_card, @options)
+    assert response.success?
+
+    credit_card_reference = response.params['porteur']
+    assert !credit_card_reference.nil?
+
+    assert capture = @gateway.subscriber_capture(@amount, response.authorization, @options)
+    assert capture.success?
+
+    assert refund = @gateway.subscriber_refund(@amount, capture.authorization, @options)
+    assert_equal 'The transaction was approved', refund.message
+    assert refund.success?
+  end
+
   def test_failed_capture
-    assert response = @gateway.capture(@amount, '', :order_id => '1', :user_reference => 'pipomolo')
-    assert_failure response
-    assert_equal "Mandatory values missing keyword:13 Type:19", response.message
+    assert response = @gateway.subscriber_capture(@amount, '', order_id: '1', user_reference: 'pipomolo')
+    assert !response.success?
+    assert_equal 'Invalid data', response.message
   end
-end
 
+  private
+
+  def default_expiration_date
+    @default_expiration_date ||= Date.new((Time.now.year + 1), 9, 30)
+  end
+
+  def credit_card(number = '4242424242424242', options = {})
+    defaults = {
+      number: number,
+      month: default_expiration_date.month,
+      year: default_expiration_date.year,
+      first_name: 'Longbob',
+      last_name: 'Longsen',
+      verification_value: options[:verification_value] || '123',
+      brand: 'visa'
+    }.update(options)
+
+    ActiveMerchant::Billing::CreditCard.new(defaults)
+  end
+end