activemerchant 1.29.1 → 1.30.0

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

@@ -0,0 +1,223 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    #
+    # NETPAY Gateway
+    #
+    # Support for NETPAY's HTTP Connector payment gateway in Mexico.
+    #
+    # The gateway sends requests as HTTP POST and receives the response details
+    # in the HTTP header, making the process really rather simple.
+    #
+    # Support for calls to the authorize and capture methods have been included
+    # as per the Netpay manuals, however, your millage may vary with these
+    # methods. At the time of writing (January 2013) they were not fully
+    # supported by the production or test gateways. This situation is
+    # expected to change within a few weeks/months.
+    #
+    # Purchases can be cancelled (`#void`) only within 24 hours of the
+    # transaction. After this, a refund should be performed instead.
+    #
+    # In addition to the regular ActiveMerchant transaction options, NETPAY
+    # also supports a `:mode` parameter. This allows testing to be peformed
+    # in production and force specific results.
+    #
+    #  * 'P' - Production
+    #  * 'A' - Approved
+    #  * 'D' - Declined
+    #  * 'R' - Random (Approved or Declined)
+    #  * 'T' - Test
+    #
+    # For example:
+    #
+    #     response = @gateway.purchase(1000, card, :mode => 'D')
+    #     response.success  # false
+    #
+    class NetpayGateway < Gateway
+      self.test_url = 'http://200.57.87.243:8855'
+      self.live_url = 'https://suite.netpay.com.mx/acquirerprd'
+
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['MX']
+
+      self.default_currency = 'MXN'
+
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.netpay.com.mx'
+
+      # The name of the gateway
+      self.display_name = 'NETPAY Gateway'
+
+      CURRENCY_CODES = {
+        "MXN" => '484'
+      }
+
+      # The header keys that we will provide in the response params hash
+      RESPONSE_KEYS = ['ResponseMsg', 'ResponseText', 'ResponseCode', 'TimeIn', 'TimeOut', 'AuthCode', 'OrderId', 'CardTypeName', 'MerchantId', 'IssuerAuthDate']
+
+      def initialize(options = {})
+        requires!(options, :store_id, :login, :password)
+        super
+      end
+
+      # Send an authorization request
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_amount(post, money, options)
+
+        commit('PreAuth', post, options)
+      end
+
+      # Capture an authorization
+      def capture(money, authorization, options = {})
+        post = {}
+        add_order_id(post, order_id_from(authorization))
+        add_amount(post, money, options)
+
+        commit('PostAuth', post, options)
+      end
+
+      # Cancel an auth/purchase within first 24 hours
+      def void(authorization, options = {})
+        post = {}
+        order_id, amount, currency = split_authorization(authorization)
+        add_order_id(post, order_id)
+        post['Total'] = (options[:amount] || amount)
+        post['CurrencyCode'] = currency
+
+        commit('Refund', post, options)
+      end
+
+      # Make a purchase.
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_amount(post, money, options)
+
+        commit('Auth', post, options)
+      end
+
+      # Perform a Credit transaction.
+      def refund(money, authorization, options = {})
+        post = {}
+        add_order_id(post, order_id_from(authorization))
+        add_amount(post, money, options)
+
+        #commit('Refund', post, options)
+        commit('Credit', post, options)
+      end
+
+      private
+
+      def add_login_data(post)
+        post['StoreId']     = @options[:store_id]
+        post['UserName']    = @options[:login]
+        post['Password']    = @options[:password]
+      end
+
+      def add_action(post, action, options)
+        post['ResourceName'] = action
+        post['ContentType']  = 'Transaction'
+        post['Mode']         = options[:mode] || 'P'
+      end
+
+      def add_order_id(post, order_id)
+        post['OrderId'] = order_id
+      end
+
+      def add_amount(post, money, options)
+        post['Total'] = amount(money)
+        post['CurrencyCode'] = currency_code(options[:currency] || currency(money))
+      end
+
+      def add_customer_data(post, options)
+        post['IPAddress'] = options[:ip] unless options[:ip].blank?
+      end
+
+      def add_invoice(post, options)
+        post['Comments'] = options[:description] if options[:description]
+      end
+
+      def add_creditcard(post, creditcard)
+        post['CardNumber']   = creditcard.number
+        post['ExpDate']      = expdate(creditcard)
+        post['CustomerName'] = creditcard.name
+        post['CVV2']         = creditcard.verification_value unless creditcard.verification_value.nil?
+      end
+
+      def build_authorization(request_params, response_params)
+        [response_params['OrderId'], request_params['Total'], request_params['CurrencyCode']].join('|')
+      end
+
+      def split_authorization(authorization)
+        order_id, amount, currency = authorization.split("|")
+        [order_id, amount, currency]
+      end
+
+      def order_id_from(authorization)
+        split_authorization(authorization).first
+      end
+
+      def expdate(credit_card)
+        year  = sprintf("%.4i", credit_card.year)
+        month = sprintf("%.2i", credit_card.month)
+
+        "#{month}/#{year[-2..-1]}"
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def parse(response, request_params)
+        response_params = params_from_response(response)
+
+        success = (response_params['ResponseCode'] == '00')
+        message = response_params['ResponseText'] || response_params['ResponseMsg']
+        options = @options.merge(:test => test?,
+                                 :authorization => build_authorization(request_params, response_params))
+
+        Response.new(success, message, response_params, options)
+      end
+
+      def commit(action, parameters, options)
+        add_login_data(parameters)
+        add_action(parameters, action, options)
+
+        post = parameters.collect{|key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        parse(ssl_post(url, post), parameters)
+      end
+
+      # Override the regular handle response so we can access the headers
+      def handle_response(response)
+        case response.code.to_i
+        when 200...300
+          response
+        else
+          raise ResponseError.new(response)
+        end
+      end
+
+      # Return a hash containing all the useful, or informative values from netpay
+      def params_from_response(response)
+        params = {}
+        RESPONSE_KEYS.each do |k|
+          params[k] = response[k] unless response[k].to_s.empty?
+        end
+        params
+      end
+
+      def currency_code(currency)
+        return currency if currency =~ /^\d+$/
+        CURRENCY_CODES[currency]
+      end
+    end
+  end
+end

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

@@ -90,7 +90,9 @@ module ActiveMerchant #:nodoc:
 
         Response.new(successful?(response), message_from(response), hash_from_xml(response),
           :test          => test?,
-          :authorization => authorization_from(response)
+          :authorization => authorization_from(response),
+          :avs_result => { :code => avs_result_from(response) },
+          :cvv_result => cvv_result_from(response)
         )
       end
 
@@ -108,7 +110,15 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorization_from(response)
-        REXML::XPath.first(response, '//confirmationNumber').text rescue nil
+        get_text_from_document(response, '//confirmationNumber')
+      end
+
+      def avs_result_from(response)
+        get_text_from_document(response, '//avsResponse')
+      end
+
+      def cvv_result_from(response)
+        get_text_from_document(response, '//cvdResponse')
       end
 
       def hash_from_xml(response)
@@ -138,6 +148,11 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
+      def get_text_from_document(document, node)
+        node = REXML::XPath.first(document, node)
+        node && node.text
+      end
+
       def cc_auth_request(money, opts)
         xml_document('ccAuthRequestV1') do |xml|
           build_merchant_account(xml, @options)
@@ -251,7 +266,7 @@ module ActiveMerchant #:nodoc:
           xml.tag! 'country', CGI.escape(addr[:country] ) if addr[:country].present?
           xml.tag! 'zip'    , CGI.escape(addr[:zip]     ) # this one's actually required
           xml.tag! 'phone'  , CGI.escape(addr[:phone]   ) if addr[:phone].present?
-          #xml.tag! 'email'        , ''
+          xml.tag! 'email', CGI.escape(opts[:email]) if opts[:email]
         end
       end
 

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

@@ -125,9 +125,13 @@ module ActiveMerchant #:nodoc:
         refund(money, authorization, options)
       end
 
-      # setting money to nil will perform a full void
-      def void(money, authorization, options = {})
-        order = build_void_request_xml(money, authorization, options)
+      def void(authorization, options = {}, deprecated = {})
+        if(!options.kind_of?(Hash))
+          deprecated("Calling the void method with an amount parameter is deprecated and will be removed in a future version.")
+          return void(options, deprecated.merge(:amount => authorization))
+        end
+
+        order = build_void_request_xml(authorization, options)
         commit(order, :void)
       end
 
@@ -396,7 +400,7 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
-      def build_void_request_xml(money, authorization, parameters = {})
+      def build_void_request_xml(authorization, parameters = {})
         tx_ref_num, order_id = split_authorization(authorization)
         xml = xml_envelope
         xml.tag! :Request do
@@ -404,7 +408,7 @@ module ActiveMerchant #:nodoc:
             add_xml_credentials(xml)
             xml.tag! :TxRefNum, tx_ref_num
             xml.tag! :TxRefIdx, parameters[:transaction_index]
-            xml.tag! :AdjustedAmt, amount(money)
+            xml.tag! :AdjustedAmt, parameters[:amount] # setting adjusted amount to nil will void entire amount
             xml.tag! :OrderID, format_order_id(order_id || parameters[:order_id])
             add_bin_merchant_and_terminal(xml, parameters)
           end

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

@@ -140,6 +140,7 @@ module ActiveMerchant #:nodoc:
         add_amount(result, money, options)
         add_invoice(result, options)
         add_address_verification_data(result, options)
+        add_optional_elements(result, options)
         result
       end
 
@@ -149,6 +150,7 @@ module ActiveMerchant #:nodoc:
         add_amount(result, money, options)
         add_invoice(result, options)
         add_reference(result, identification)
+        add_optional_elements(result, options)
         result
       end
 
@@ -157,6 +159,7 @@ module ActiveMerchant #:nodoc:
         add_credit_card(result, credit_card)
         add_amount(result, 100, options) #need to make an auth request for $1
         add_token_request(result, options)
+        add_optional_elements(result, options)
         result
       end
 
@@ -209,7 +212,7 @@ module ActiveMerchant #:nodoc:
 
       def add_invoice(xml, options)
         xml.add_element("TxnId").text = options[:order_id].to_s.slice(0, 16) unless options[:order_id].blank?
-        xml.add_element("MerchantReference").text = options[:description] unless options[:description].blank?
+        xml.add_element("MerchantReference").text = options[:description].to_s.slice(0, 50) unless options[:description].blank?
       end
 
       def add_address_verification_data(xml, options)
@@ -223,6 +226,52 @@ module ActiveMerchant #:nodoc:
         xml.add_element("AvsPostCode").text = address[:zip]
       end
 
+      # The options hash may contain optional data which will be passed
+      # through the the specialized optional fields at PaymentExpress
+      # as follows:
+      #
+      #     {
+      #       :client_type => :web, # Possible values are: :web, :ivr, :moto, :unattended, :internet, or :recurring
+      #       :txn_data1 => "String up to 255 characters",
+      #       :txn_data2 => "String up to 255 characters",
+      #       :txn_data3 => "String up to 255 characters"
+      #     }
+      #
+      # +:client_type+, while not documented for PxPost, will be sent as
+      # the +ClientType+ XML element as described in the documentation for
+      # the PaymentExpress WebService: http://www.paymentexpress.com/Technical_Resources/Ecommerce_NonHosted/WebService#clientType
+      # (PaymentExpress have confirmed that this value works the same in PxPost).
+      # The value sent for +:client_type+ will be normalized and sent
+      # as one of the explicit values allowed by PxPost:
+      #
+      #     :web        => "Web"
+      #     :ivr        => "IVR"
+      #     :moto       => "MOTO"
+      #     :unattended => "Unattended"
+      #     :internet   => "Internet"
+      #     :recurring  => "Recurring"
+      #
+      # If you set the +:client_type+ to any value not listed above,
+      # the ClientType element WILL NOT BE INCLUDED at all in the
+      # POST data.
+      #
+      # +:txn_data1+, +:txn_data2+, and +:txn_data3+ will be sent as
+      # +TxnData1+, +TxnData2+, and +TxnData3+, respectively, and are
+      # free form fields of the merchant's choosing, as documented here:
+      # http://www.paymentexpress.com/technical_resources/ecommerce_nonhosted/pxpost.html#txndata
+      #
+      # These optional elements are added to all transaction types:
+      # +purchase+, +authorize+, +capture+, +refund+, +store+
+      def add_optional_elements(xml, options)
+        if client_type = normalized_client_type(options[:client_type])
+          xml.add_element("ClientType").text = client_type
+        end
+
+        xml.add_element("TxnData1").text = options[:txn_data1].to_s.slice(0,255) unless options[:txn_data1].blank?
+        xml.add_element("TxnData2").text = options[:txn_data2].to_s.slice(0,255) unless options[:txn_data2].blank?
+        xml.add_element("TxnData3").text = options[:txn_data3].to_s.slice(0,255) unless options[:txn_data3].blank?
+      end
+
       def new_transaction
         REXML::Document.new.add_element("Txn")
       end
@@ -266,6 +315,18 @@ module ActiveMerchant #:nodoc:
       def format_date(month, year)
         "#{format(month, :two_digits)}#{format(year, :two_digits)}"
       end
+
+      def normalized_client_type(client_type_from_options)
+        case client_type_from_options.to_s.downcase
+          when 'web'        then "Web"
+          when 'ivr'        then "IVR"
+          when 'moto'       then "MOTO"
+          when 'unattended' then "Unattended"
+          when 'internet'   then "Internet"
+          when 'recurring'  then "Recurring"
+          else nil
+        end
+      end
     end
 
     class PaymentExpressResponse < Response

data/lib/active_merchant/billing/gateways/paypal/paypal_common_api.rb

@@ -397,7 +397,7 @@ module ActiveMerchant #:nodoc:
         transaction_search_optional_fields = %w{ Payer ReceiptID Receiver
                                                  TransactionID InvoiceID CardNumber
                                                  AuctionItemNumber TransactionClass
-                                                 CurrencyCode Status }
+                                                 CurrencyCode Status ProfileID }
         build_request_wrapper('TransactionSearch') do |xml|
           xml.tag! 'StartDate', date_to_iso(options[:start_date])
           xml.tag! 'EndDate', date_to_iso(options[:end_date]) unless options[:end_date].blank?

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

@@ -1,5 +1,6 @@
 require File.dirname(__FILE__) + '/paypal/paypal_common_api'
 require File.dirname(__FILE__) + '/paypal/paypal_express_response'
+require File.dirname(__FILE__) + '/paypal/paypal_recurring_api'
 require File.dirname(__FILE__) + '/paypal_express_common'
 
 module ActiveMerchant #:nodoc:
@@ -7,6 +8,7 @@ module ActiveMerchant #:nodoc:
     class PaypalExpressGateway < Gateway
       include PaypalCommonAPI
       include PaypalExpressCommon
+      include PaypalRecurringApi
 
       NON_STANDARD_LOCALE_CODES = {
         'DK' => 'da_DK',

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

@@ -0,0 +1,157 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PinGateway < Gateway
+      self.test_url = 'https://test-api.pin.net.au/1'
+      self.live_url = 'https://api.pin.net.au/1'
+
+      self.default_currency = 'AUD'
+      self.money_format = :cents
+      self.supported_countries = ['AU']
+      self.supported_cardtypes = [:visa, :master]
+      self.homepage_url = 'http://www.pin.net.au/'
+      self.display_name = 'Pin'
+
+      def initialize(options = {})
+        requires!(options, :api_key)
+        super
+      end
+
+      # Create a charge using a credit card, card token or customer token
+      #
+      # To charge a credit card: purchase([money], [creditcard hash], ...)
+      # To charge a customer: purchase([money], [token], ...)
+      def purchase(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_customer_data(post, options)
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+
+        commit('charges', post)
+      end
+
+      # Create a customer and associated credit card. The token that is returned
+      # can be used instead of a credit card parameter in the purchase method
+      def store(creditcard, options = {})
+        post = {}
+
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_address(post, creditcard, options)
+        commit('customers', post)
+      end
+
+      # Refund a transaction, note that the money attribute is ignored at the
+      # moment as the API does not support partial refunds. The parameter is
+      # kept for compatibility reasons
+      def refund(money, token, options = {})
+        commit("charges/#{CGI.escape(token)}/refunds", :amount => amount(money))
+      end
+
+      private
+      def add_amount(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:currency] = post[:currency].upcase if post[:currency]
+      end
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email]
+        post[:ip_address] = options[:ip]
+      end
+
+      def add_address(post, creditcard, options)
+        return if creditcard.kind_of?(String)
+        address = (options[:billing_address] || options[:address])
+        return unless address
+
+        post[:card] ||= {}
+        post[:card].merge!(
+          :address_line1 => address[:address1],
+          :address_city => address[:city],
+          :address_postcode => address[:zip],
+          :address_state => address[:state],
+          :address_country => address[:country]
+        )
+      end
+
+      def add_invoice(post, options)
+        post[:description] = options[:description]
+      end
+
+      def add_creditcard(post, creditcard)
+        if creditcard.respond_to?(:number)
+          post[:card] ||= {}
+
+          post[:card].merge!(
+            :number => creditcard.number,
+            :expiry_month => creditcard.month,
+            :expiry_year => creditcard.year,
+            :cvc => creditcard.verification_value,
+            :name => "#{creditcard.first_name} #{creditcard.last_name}"
+          )
+        elsif creditcard.kind_of?(String)
+          post[:customer_token] = creditcard
+        end
+      end
+
+      def headers
+        {
+          "Content-Type" => "application/json",
+          "Authorization" => "Basic #{Base64.strict_encode64(options[:api_key] + ':').strip}"
+        }
+      end
+
+      def commit(action, params)
+        url = "#{test? ? test_url : live_url}/#{action}"
+
+        begin
+          body = parse(ssl_post(url, post_data(params), headers))
+        rescue ResponseError => e
+          body = parse(e.response.body)
+        end
+
+        if body["response"]
+          success_response(body)
+        elsif body["error"]
+          error_response(body)
+        end
+      end
+
+      def success_response(body)
+        response = body["response"]
+        Response.new(
+          true,
+          response['status_message'],
+          body,
+          :authorization => token(response),
+          :test => test?
+        )
+      end
+
+      def error_response(body)
+        Response.new(
+          false,
+          body['error_description'],
+          body,
+          :authorization => nil,
+          :test => test?
+        )
+      end
+
+      def token(response)
+        response['token']
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def post_data(parameters = {})
+        parameters.to_json
+      end
+    end
+  end
+end

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

@@ -126,6 +126,7 @@ module ActiveMerchant #:nodoc:
         parameters[:trans_request_id] ||= SecureRandom.hex(10)
 
         req = build_request(type, money, parameters)
+
         data = ssl_post(url, req, "Content-Type" => "application/x-qbmsxml")
         response = parse(type, data)
         message = (response[:status_message] || '').strip
@@ -260,8 +261,8 @@ module ActiveMerchant #:nodoc:
 
       def add_address(xml, parameters)
         if address = parameters[:billing_address] || parameters[:address]
-          xml.tag!("CreditCardAddress", address[:address1][0...30])
-          xml.tag!("CreditCardPostalCode", address[:zip][0...9])
+          xml.tag!("CreditCardAddress", (address[:address1] || "")[0...30])
+          xml.tag!("CreditCardPostalCode", (address[:zip] || "")[0...9])
         end
       end