activemerchant 1.27.0 → 1.28.0

data.tar.gz.sig

@@ -0,0 +1,3 @@
+�LB0�q ^���C�D���i��:�����nkU�[su��&W�֩�v��_���eN��B�"��Q�*J�1͌ә�NT'�9b"*��}C}���~���Ց�c�W�.�!�Xws�c
+P[�4|��9�	�1ۺ4�<�]a˫�E����z�<VA�u��С  ��7^4��z;�zխ�v�ә@?�N��	�]�2馯�Z���@{7��6{\���
+B��j�E@):�9AxR���6�mDVO2�

data/CHANGELOG

@@ -1,5 +1,18 @@
 = ActiveMerchant CHANGELOG
 
+== Version 1.28.0 (August 10, 2012)
+
+* PayPal Express: support non standard locale codes [Soleone]
+* Litle: allow setting test mode per transaction [jduff]
+* Add Banwire gateway [acolin]
+* Authorize.Net CIM gateway: Move cardCode after order to comply with the XSD [davetron5000]
+* Add WebMoney integration [Mehonoshin]
+* EasyPay: Make symmetric with other integrations [nashby]
+* Add Paysbuy integration [divineforest]
+* Bogus gateway: Use last digit for pass/fail [mipearson]
+* Elavon gateway: Separate from Viaklix, implement refund & void [duff]
+* Orbital gateway: Update to API version 5.6 and add support for profile requests [rbarazi]
+
 == Version 1.27.0 (August 10, 2012)
 
 * Add First Data integration [courtland]

data/README.md

@@ -87,6 +87,7 @@ The [ActiveMerchant Wiki](http://github.com/Shopify/active_merchant/wikis) conta
 * [Authorize.Net](http://www.authorize.net/) - US
 * [Authorize.Net CIM](http://www.authorize.net/) - US
 * [Balanced](https://www.balancedpayments.com/) - US
+* [Banwire](https://www.banwire.com/) - MX
 * [Barclays ePDQ](http://www.barclaycard.co.uk/business/accepting-payments/epdq-mpi/) - UK
 * [Beanstream.com](http://www.beanstream.com/) - CA
 * [BluePay](http://www.bluepay.com/) - US
@@ -125,7 +126,7 @@ The [ActiveMerchant Wiki](http://github.com/Shopify/active_merchant/wikis) conta
 * [NMI](http://nmi.com/) - US
 * [Ogone DirectLink](http://www.ogone.com) - BE, DE, FR, NL, AT, CH
 * [Optimal Payments](http://www.optimalpayments.com/) - CA, US, UK
-* [Orbital Paymentech](http://chasepaymentech.com/) - CA, US
+* [Orbital Paymentech](http://chasepaymentech.com/) - CA, US, UK, GB
 * [PayBox Direct](http://www.paybox.com) - FR
 * [PayGate PayXML](http://paygate.co.za/) - US, ZA
 * [PayJunction](http://www.payjunction.com/) - US
@@ -181,11 +182,13 @@ The [ActiveMerchant Wiki](http://github.com/Shopify/active_merchant/wikis) conta
 * [Nochex](http://www.nochex.com)
 * [Paxum](https://www.paxum.com/)
 * [PayPal Website Payments Standard](https://www.paypal.com/cgi-bin/webscr?cmd#_wp-standard-overview-outside)
+* [Paysbuy](https://www.paysbuy.com/) - TH
 * [Robokassa](http://robokassa.ru/)
 * [SagePay Form](http://www.sagepay.com/products_services/sage_pay_go/integration/form)
 * [Suomen Maksuturva](https://www.maksuturva.fi/services/vendor_services/integration_guidelines.html)
 * [Valitor](http://www.valitor.is/) - IS
 * [Verkkomaksut](http://www.verkkomaksut.fi) - FI
+* [WebMoney](http://www.webmoney.ru) - RU
 * [WebPay](http://webpay.by/)
 * [WorldPay](http://www.worldpay.com)
 

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

@@ -673,9 +673,11 @@ module ActiveMerchant #:nodoc:
                 xml.tag!('customerProfileId', transaction[:customer_profile_id])
                 xml.tag!('customerPaymentProfileId', transaction[:customer_payment_profile_id])
                 xml.tag!('approvalCode', transaction[:approval_code]) if transaction[:type] == :capture_only
-                tag_unless_blank(xml, 'cardCode', transaction[:card_code])
             end
             add_order(xml, transaction[:order]) if transaction[:order].present?
+            unless [:void,:refund,:prior_auth_capture].include?(transaction[:type])
+              tag_unless_blank(xml, 'cardCode', transaction[:card_code])
+            end
           end
         end
       end

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

@@ -0,0 +1,92 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BanwireGateway < Gateway
+      URL = 'https://banwire.com/api.pago_pro'
+
+      self.supported_countries = ['MX']
+      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.homepage_url = 'http://www.banwire.com/'
+      self.display_name = 'Banwire'
+
+      def initialize(options = {})
+        requires!(options, :login)
+        @options = options
+        super
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_response_type(post)
+        add_customer_data(post, options)
+        add_order_data(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        add_customer_data(post, options)
+        add_amount(post, money, options)
+
+        commit(money, post)
+      end
+
+      private
+
+      def add_response_type(post)
+        post[:response_format] = "JSON"
+      end
+
+      def add_customer_data(post, options)
+        post[:user] = @options[:login]
+        post[:phone] = options[:billing_address][:phone]
+        post[:mail] = options[:email]
+      end
+
+      def add_order_data(post, options)
+        post[:reference] = options[:order_id]
+        post[:concept] = options[:description]
+      end
+
+      def add_address(post, creditcard, options)
+        post[:address] = options[:billing_address][:address1]
+        post[:post_code] = options[:billing_address][:zipcode]
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:card_num] = creditcard.number
+        post[:card_name] = creditcard.name
+        post[:card_type] = card_brand(creditcard)
+        post[:card_exp] = "#{sprintf("%02d", creditcard.month)}/#{"#{creditcard.year}"[-2, 2]}"
+        post[:card_ccv2] = creditcard.verification_value
+      end
+
+      def add_amount(post, money, options)
+        post[:ammount] = amount(money)
+        post[:currency] = options[:currency]
+      end
+
+      def card_brand(card)
+        brand = super
+        ({"master" => "mastercard", "american_express" => "amex"}[brand] || brand)
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(money, parameters)
+        response = parse(ssl_post(URL, post_data(parameters)))
+        Response.new(success?(response),
+                     response["message"],
+                     response,
+                     :test => test?,
+                     :authorization => response["code_auth"])
+      end
+
+      def success?(response)
+        (response["response"] == "ok")
+      end
+
+      def post_data(parameters = {})
+        parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+    end
+  end
+end

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

@@ -3,57 +3,57 @@ module ActiveMerchant #:nodoc:
     # Bogus Gateway
     class BogusGateway < Gateway
       AUTHORIZATION = '53433'
-      
+
       SUCCESS_MESSAGE = "Bogus Gateway: Forced success"
       FAILURE_MESSAGE = "Bogus Gateway: Forced failure"
-      ERROR_MESSAGE = "Bogus Gateway: Use CreditCard number 1 for success, 2 for exception and anything else for error"
-      CREDIT_ERROR_MESSAGE = "Bogus Gateway: Use CreditCard number 1 for success, 2 for exception and anything else for error"
-      UNSTORE_ERROR_MESSAGE = "Bogus Gateway: Use trans_id 1 for success, 2 for exception and anything else for error"
-      CAPTURE_ERROR_MESSAGE = "Bogus Gateway: Use authorization number 1 for exception, 2 for error and anything else for success"
-      VOID_ERROR_MESSAGE = "Bogus Gateway: Use authorization number 1 for exception, 2 for error and anything else for success"
-      REFUND_ERROR_MESSAGE = "Bogus Gateway: Use trans_id number 1 for exception, 2 for error and anything else for success"
-      
+      ERROR_MESSAGE = "Bogus Gateway: Use CreditCard number ending in 1 for success, 2 for exception and anything else for error"
+      CREDIT_ERROR_MESSAGE = "Bogus Gateway: Use CreditCard number ending in 1 for success, 2 for exception and anything else for error"
+      UNSTORE_ERROR_MESSAGE = "Bogus Gateway: Use trans_id ending in 1 for success, 2 for exception and anything else for error"
+      CAPTURE_ERROR_MESSAGE = "Bogus Gateway: Use authorization number ending in 1 for exception, 2 for error and anything else for success"
+      VOID_ERROR_MESSAGE = "Bogus Gateway: Use authorization number ending in 1 for exception, 2 for error and anything else for success"
+      REFUND_ERROR_MESSAGE = "Bogus Gateway: Use trans_id number ending in 1 for exception, 2 for error and anything else for success"
+
       self.supported_countries = ['US']
       self.supported_cardtypes = [:bogus]
       self.homepage_url = 'http://example.com'
       self.display_name = 'Bogus'
-      
+
       def authorize(money, credit_card_or_reference, options = {})
         money = amount(money)
         case normalize(credit_card_or_reference)
-        when '1'
+        when /1$/
           Response.new(true, SUCCESS_MESSAGE, {:authorized_amount => money}, :test => true, :authorization => AUTHORIZATION )
-        when '2'
+        when /2$/
           Response.new(false, FAILURE_MESSAGE, {:authorized_amount => money, :error => FAILURE_MESSAGE }, :test => true)
         else
           raise Error, ERROR_MESSAGE
-        end      
+        end
       end
-  
+
       def purchase(money, credit_card_or_reference, options = {})
         money = amount(money)
         case normalize(credit_card_or_reference)
-        when '1', AUTHORIZATION
+        when /1$/, AUTHORIZATION
           Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true)
-        when '2'
+        when /2$/
           Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE },:test => true)
         else
           raise Error, ERROR_MESSAGE
         end
       end
- 
+
       def recurring(money, credit_card_or_reference, options = {})
         money = amount(money)
         case normalize(credit_card_or_reference)
-        when '1'
+        when /1$/
           Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true)
-        when '2'
+        when /2$/
           Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE },:test => true)
         else
           raise Error, ERROR_MESSAGE
         end
       end
- 
+
       def credit(money, credit_card_or_reference, options = {})
         if credit_card_or_reference.is_a?(String)
           deprecated CREDIT_DEPRECATION_MESSAGE
@@ -62,9 +62,9 @@ module ActiveMerchant #:nodoc:
 
         money = amount(money)
         case normalize(credit_card_or_reference)
-        when '1'
+        when /1$/
           Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true )
-        when '2'
+        when /2$/
           Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true)
         else
           raise Error, CREDIT_ERROR_MESSAGE
@@ -74,21 +74,21 @@ module ActiveMerchant #:nodoc:
       def refund(money, reference, options = {})
         money = amount(money)
         case reference
-        when '1'
+        when /1$/
           raise Error, REFUND_ERROR_MESSAGE
-        when '2'
+        when /2$/
           Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true)
         else
           Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true)
         end
       end
- 
+
       def capture(money, reference, options = {})
         money = amount(money)
         case reference
-        when '1'
+        when /1$/
           raise Error, CAPTURE_ERROR_MESSAGE
-        when '2'
+        when /2$/
           Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true)
         else
           Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true)
@@ -97,31 +97,31 @@ module ActiveMerchant #:nodoc:
 
       def void(reference, options = {})
         case reference
-        when '1'
+        when /1$/
           raise Error, VOID_ERROR_MESSAGE
-        when '2'
+        when /2$/
           Response.new(false, FAILURE_MESSAGE, {:authorization => reference, :error => FAILURE_MESSAGE }, :test => true)
         else
           Response.new(true, SUCCESS_MESSAGE, {:authorization => reference}, :test => true)
         end
       end
-      
+
       def store(credit_card_or_reference, options = {})
         case normalize(credit_card_or_reference)
-        when '1'
+        when /1$/
           Response.new(true, SUCCESS_MESSAGE, {:billingid => '1'}, :test => true, :authorization => AUTHORIZATION)
-        when '2'
+        when /2$/
           Response.new(false, FAILURE_MESSAGE, {:billingid => nil, :error => FAILURE_MESSAGE }, :test => true)
         else
           raise Error, ERROR_MESSAGE
-        end              
+        end
       end
-      
+
       def unstore(reference, options = {})
         case reference
-        when '1'
+        when /1$/
           Response.new(true, SUCCESS_MESSAGE, {}, :test => true)
-        when '2'
+        when /2$/
           Response.new(false, FAILURE_MESSAGE, {:error => FAILURE_MESSAGE },:test => true)
         else
           raise Error, UNSTORE_ERROR_MESSAGE

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

@@ -29,7 +29,9 @@ module ActiveMerchant #:nodoc:
     #   puts response.message       # Retrieve the message returned by Elavon
     #   puts response.authorization # Retrieve the unique transaction ID returned by Elavon
     #
-    class ElavonGateway < ViaklixGateway
+    class ElavonGateway < Gateway
+      class_attribute :test_url, :live_url, :delimiter, :actions
+
       self.test_url = 'https://demo.myvirtualmerchant.com/VirtualMerchantDemo/process.do'
       self.live_url = 'https://www.myvirtualmerchant.com/VirtualMerchant/process.do'
 
@@ -42,29 +44,59 @@ module ActiveMerchant #:nodoc:
       self.actions = {
         :purchase => 'CCSALE',
         :credit => 'CCCREDIT',
+        :refund => 'CCRETURN',
         :authorize => 'CCAUTHONLY',
-        :capture => 'CCFORCE'
+        :capture => 'CCFORCE',
+        :void => 'CCVOID'
       }
-      
+
+      # Initialize the Gateway
+      #
+      # The gateway requires that a valid login and password be passed
+      # in the +options+ hash.
+      #
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- Merchant ID
+      # * <tt>:password</tt> -- PIN
+      # * <tt>:user</tt> -- Specify a subuser of the account (optional)
+      # * <tt>:test => +true+ or +false+</tt> -- Force test transactions
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end
+
+      # Make a purchase
+      def purchase(money, creditcard, options = {})
+        form = {}
+        add_invoice(form, options)
+        add_creditcard(form, creditcard)
+        add_address(form, options)
+        add_customer_data(form, options)
+        add_test_mode(form, options)
+        commit(:purchase, money, form)
+      end
+
       # Authorize a credit card for a given amount.
-      # 
+      #
       # ==== Parameters
       # * <tt>money</tt> - The amount to be authorized as an Integer value in cents.
       # * <tt>credit_card</tt> - The CreditCard details for the transaction.
       # * <tt>options</tt>
-      #   * <tt>:billing_address</tt> - The billing address for the cardholder.      
+      #   * <tt>:billing_address</tt> - The billing address for the cardholder.
       def authorize(money, creditcard, options = {})
         form = {}
         add_invoice(form, options)
-        add_creditcard(form, creditcard)        
-        add_address(form, options)   
+        add_creditcard(form, creditcard)
+        add_address(form, options)
         add_customer_data(form, options)
         add_test_mode(form, options)
         commit(:authorize, money, form)
       end
-      
+
       # Capture authorized funds from a credit card.
-      # 
+      #
       # ==== Parameters
       # * <tt>money</tt> - The amount to be captured as an Integer value in cents.
       # * <tt>authorization</tt> - The approval code returned from the initial authorization.
@@ -72,33 +104,116 @@ module ActiveMerchant #:nodoc:
       #   * <tt>:credit_card</tt> - The CreditCard details from the initial transaction (required).
       def capture(money, authorization, options = {})
         requires!(options, :credit_card)
-        
+
         form = {}
-        add_reference(form, authorization)
+        add_approval_code(form, authorization)
         add_invoice(form, options)
         add_creditcard(form, options[:credit_card])
         add_customer_data(form, options)
         add_test_mode(form, options)
         commit(:capture, money, form)
       end
-      
+
+      # Refund a transaction.
+      #
+      # This transaction indicates to the gateway that
+      # money should flow from the merchant to the customer.
+      #
+      # ==== Parameters
+      #
+      # * <tt>money</tt> -- The amount to be credited to the customer as an Integer value in cents.
+      # * <tt>identification</tt> -- The ID of the original transaction against which the refund is being issued.
+      # * <tt>options</tt> -- A hash of parameters.
+      def refund(money, identification, options = {})
+        form = {}
+        add_txn_id(form, identification)
+        add_test_mode(form, options)
+        commit(:refund, money, form)
+      end
+
+      # Void a previous transaction
+      #
+      # ==== Parameters
+      #
+      # * <tt>authorization</tt> - The authorization returned from the previous request.
+      def void(identification, options = {})
+        form = {}
+        add_txn_id(form, identification)
+        add_test_mode(form, options)
+        commit(:void, nil, form)
+      end
+
+      # Make a credit to a card.  Use the refund method if you'd like to credit using
+      # previous transaction
+      #
+      # ==== Parameters
+      # * <tt>money</tt> - The amount to be credited as an Integer value in cents.
+      # * <tt>creditcard</tt> - The credit card to be credited.
+      # * <tt>options</tt>
+      def credit(money, creditcard, options = {})
+        if creditcard.is_a?(String)
+          raise ArgumentError, "Reference credits are not supported. Please supply the original credit card or use the #refund method."
+        end
+
+        form = {}
+        add_invoice(form, options)
+        add_creditcard(form, creditcard)
+        add_address(form, options)
+        add_customer_data(form, options)
+        add_test_mode(form, options)
+        commit(:credit, money, form)
+      end
+
+
       private
-      def add_reference(form, authorization)
-        form[:approval_code] = authorization
+      def add_invoice(form,options)
+        form[:invoice_number] = (options[:order_id] || options[:invoice]).to_s.slice(0, 10)
+        form[:description] = options[:description].to_s.slice(0, 255)
+      end
+
+      def add_approval_code(form, authorization)
+        form[:approval_code] = authorization.split(';').first
+      end
+
+      def add_txn_id(form, authorization)
+        form[:txn_id] = authorization.split(';').last
       end
-      
+
       def authorization_from(response)
-        response['approval_code']
+        [response['approval_code'], response['txn_id']].join(';')
+      end
+
+      def add_creditcard(form, creditcard)
+        form[:card_number] = creditcard.number
+        form[:exp_date] = expdate(creditcard)
+
+        if creditcard.verification_value?
+          add_verification_value(form, creditcard)
+        end
+
+        form[:first_name] = creditcard.first_name.to_s.slice(0, 20)
+        form[:last_name] = creditcard.last_name.to_s.slice(0, 30)
       end
-      
+
       def add_verification_value(form, creditcard)
-        form[:cvv2cvc2] = creditcard.verification_value 
+        form[:cvv2cvc2] = creditcard.verification_value
         form[:cvv2cvc2_indicator] = '1'
       end
 
+      def add_customer_data(form, options)
+        form[:email] = options[:email].to_s.slice(0, 100) unless options[:email].blank?
+        form[:customer_code] = options[:customer].to_s.slice(0, 10) unless options[:customer].blank?
+      end
+
+      def expdate(creditcard)
+        year  = sprintf("%.4i", creditcard.year)
+        month = sprintf("%.2i", creditcard.month)
+        "#{month}#{year[2..3]}"
+      end
+
       def add_address(form,options)
-        billing_address = options[:billing_address] || options[:address] 
-        
+        billing_address = options[:billing_address] || options[:address]
+
         if billing_address
           form[:avs_address]    = billing_address[:address1].to_s.slice(0, 30)
           form[:address2]       = billing_address[:address2].to_s.slice(0, 30)
@@ -109,7 +224,7 @@ module ActiveMerchant #:nodoc:
           form[:phone]          = billing_address[:phone].to_s.slice(0, 20)
           form[:country]        = billing_address[:country].to_s.slice(0, 50)
         end
-                
+
         if shipping_address = options[:shipping_address]
           first_name, last_name = parse_first_and_last_name(shipping_address[:name])
           form[:ship_to_first_name]     = first_name.to_s.slice(0, 20)
@@ -123,14 +238,68 @@ module ActiveMerchant #:nodoc:
           form[:ship_to_zip]            = shipping_address[:zip].to_s.slice(0, 10)
         end
       end
-      
+
+      def parse_first_and_last_name(value)
+        name = value.to_s.split(' ')
+
+        last_name = name.pop || ''
+        first_name = name.join(' ')
+        [ first_name, last_name ]
+      end
+
+      def add_test_mode(form, options)
+        form[:test_mode] = 'TRUE' if options[:test_mode]
+      end
+
       def message_from(response)
         success?(response) ? response['result_message'] : response['errorMessage']
       end
-      
+
       def success?(response)
         !response.has_key?('errorMessage')
       end
+
+      def commit(action, money, parameters)
+        parameters[:amount] = amount(money)
+        parameters[:transaction_type] = self.actions[action]
+
+        response = parse( ssl_post(test? ? self.test_url : self.live_url, post_data(parameters)) )
+
+        Response.new(response['result'] == '0', message_from(response), response,
+          :test => @options[:test] || test?,
+          :authorization => authorization_from(response),
+          :avs_result => { :code => response['avs_response'] },
+          :cvv_result => response['cvv2_response']
+        )
+      end
+
+      def post_data(parameters)
+        result = preamble
+        result.merge!(parameters)
+        result.collect { |key, value| "ssl_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+
+      def preamble
+        result = {
+          'merchant_id'   => @options[:login],
+          'pin'           => @options[:password],
+          'show_form'     => 'false',
+          'result_format' => 'ASCII'
+        }
+
+        result['user_id'] = @options[:user] unless @options[:user].blank?
+        result
+      end
+
+      def parse(msg)
+        resp = {}
+        msg.split(self.delimiter).collect{|li|
+            key, value = li.split("=")
+            resp[key.strip.gsub(/^ssl_/, '')] = value.to_s.strip
+          }
+        resp
+      end
+
     end
   end
 end