activemerchant 1.41.0 → 1.42.0

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

@@ -0,0 +1,187 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PacNetRavenGateway < Gateway
+      self.test_url = 'https://demo.deepcovelabs.com/realtime/'
+      self.live_url = 'https://raven.pacnetservices.com/realtime/'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.money_format = :cents
+      self.default_currency = 'USD'
+      self.homepage_url = 'http://www.pacnetservices.com/'
+      self.display_name = 'Raven PacNet'
+
+      def initialize(options = {})
+        requires!(options, :user, :secret, :prn)
+        super
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_creditcard(post, creditcard)
+        add_currency_code(post, money, options)
+        add_address(post, options)
+        post['PRN'] = @options[:prn]
+
+        commit('cc_preauth', money, post)
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_currency_code(post, money, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        post['PRN'] = @options[:prn]
+
+        commit('cc_debit', money, post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        post['TrackingNumber'] = authorization
+        post['PymtType'] = options[:pymt_type] || 'cc_debit'
+
+        commit('void', nil, post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        post['PreauthNumber'] = authorization
+        post['PRN'] = @options[:prn]
+        add_currency_code(post, money, options)
+
+        commit('cc_settle', money, post)
+      end
+
+      def refund(money, template_number, options = {})
+        post = {}
+        post['PRN'] = @options[:prn]
+        post['TemplateNumber'] = template_number
+        add_currency_code(post, money, options)
+
+        commit('cc_refund', money, post)
+      end
+
+      private
+
+      def add_creditcard(post, creditcard)
+        post['CardNumber'] = creditcard.number
+        post['Expiry'] = expdate(creditcard)
+        post['CVV2'] = creditcard.verification_value if creditcard.verification_value
+      end
+
+      def add_currency_code(post, money, options)
+        post['Currency'] = options[:currency] || currency(money)
+      end
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post['BillingStreetAddressLineOne']   = address[:address1].to_s
+          post['BillingStreetAddressLineFour']  = address[:address2].to_s
+          post['BillingPostalCode']             = address[:zip].to_s
+        end
+      end
+
+      def parse(body)
+        Hash[body.split('&').map{|x| x.split('=').map{|x| CGI.unescape(x)}}]
+      end
+
+      def commit(action, money, parameters)
+        parameters['Amount'] = amount(money) unless action == 'void'
+
+        data = ssl_post url(action), post_data(action, parameters)
+
+        response = parse(data)
+        response[:action] = action
+
+        message = message_from(response)
+
+        test_mode = test? || message =~ /TESTMODE/
+
+        Response.new(success?(response), message, response,
+          :test => test_mode,
+          :authorization => response['TrackingNumber'],
+          :fraud_review => fraud_review?(response),
+          :avs_result => { :postal_match => response['AVSPostalResponseCode'], :street_match => response['AVSAddressResponseCode'] },
+          :cvv_result => response['CVV2ResponseCode']
+        )
+      end
+
+      def url(action)
+        (test? ? self.test_url : self.live_url) + endpoint(action)
+      end
+
+      def endpoint(action)
+        return 'void' if action == 'void'
+        'submit'
+      end
+
+      def fraud_review?(response)
+        false
+      end
+
+      def success?(response)
+        if %w(cc_settle cc_debit cc_preauth cc_refund).include?(response[:action])
+          !response['ApprovalCode'].nil? and response['ErrorCode'].nil? and response['Status'] == 'Approved'
+        elsif response[:action] = 'void'
+          !response['ApprovalCode'].nil? and response['ErrorCode'].nil? and response['Status'] == 'Voided'
+        end
+      end
+
+      def message_from(response)
+        return response['Message'] if response['Message']
+
+        if response['Status'] == 'Approved'
+          "This transaction has been approved"
+        elsif response['Status'] == 'Declined'
+          "This transaction has been declined"
+        elsif response['Status'] == 'Voided'
+          "This transaction has been voided"
+        else
+          response['Status']
+        end
+      end
+
+      def post_data(action, parameters = {})
+        post = {}
+
+        post['PymtType']      = action
+        post['RAPIVersion']   = '2'
+        post['UserName']      = @options[:user]
+        post['Timestamp']     = timestamp
+        post['RequestID']     = request_id
+        post['Signature']     = signature(action, post, parameters)
+
+        request = post.merge(parameters).collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request
+      end
+
+      def timestamp
+        Time.now.strftime("%Y-%m-%dT%H:%M:%S.Z")
+      end
+
+      def request_id
+        (0...21).map{(65+rand(26)).chr}.join.downcase
+      end
+
+      def signature(action, post, parameters = {})
+        string = if %w(cc_settle cc_debit cc_preauth cc_refund).include?(action)
+          post['UserName'] + post['Timestamp'] + post['RequestID'] + post['PymtType'] + parameters['Amount'].to_s + parameters['Currency']
+        elsif action == 'void'
+          post['UserName'] + post['Timestamp'] + post['RequestID'] + parameters['TrackingNumber']
+        else
+          post['UserName']
+        end
+        Digest::HMAC.hexdigest(string, @options[:secret], Digest::SHA1)
+      end
+
+      def expdate(creditcard)
+        year  = sprintf("%.4i", creditcard.year)
+        month = sprintf("%.2i", creditcard.month)
+
+        "#{month}#{year[-2..-1]}"
+      end
+    end
+  end
+end
+

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

@@ -17,27 +17,11 @@ module ActiveMerchant #:nodoc:
       end
 
       def purchase(money, payment_method, options = {})
-        case payment_method
-        when String
-          purchase_with_token(money, payment_method, options)
-        else
-          MultiResponse.run do |r|
-            r.process { save_card(payment_method) }
-            r.process { purchase_with_token(money, r.authorization, options) }
-          end
-        end
+        action_with_token(:purchase, money, payment_method, options)
       end
 
       def authorize(money, payment_method, options = {})
-        case payment_method
-        when String
-          authorize_with_token(money, payment_method, options)
-        else
-          MultiResponse.run do |r|
-            r.process { save_card(payment_method) }
-            r.process { authorize_with_token(money, r.authorization, options) }
-          end
-        end
+        action_with_token(:authorize, money, payment_method, options)
       end
 
       def capture(money, authorization, options = {})
@@ -110,6 +94,18 @@ module ActiveMerchant #:nodoc:
         ].join(";")
       end
 
+      def action_with_token(action, money, payment_method, options)
+        case payment_method
+        when String
+          self.send("#{action}_with_token", money, payment_method, options)
+        else
+          MultiResponse.run do |r|
+            r.process { save_card(payment_method) }
+            r.process { self.send("#{action}_with_token", money, r.authorization, options) }
+          end
+        end
+      end
+
       def purchase_with_token(money, card_token, options)
         post = {}
 
@@ -147,17 +143,12 @@ module ActiveMerchant #:nodoc:
       def response_for_save_from(raw_response)
         options = { :test => test? }
 
-        parsed = JSON.parse(raw_response.sub(/jsonPFunction\(/, '').sub(/\)\z/, ''))
-        if parsed['error']
-          succeeded = false
-          message = parsed['error']['message']
-        else
-          succeeded = parsed['transaction']['processing']['result'] == 'ACK'
-          message = parsed['transaction']['processing']['return']['message']
-          options[:authorization] = parsed['transaction']['identification']['uniqueId'] if succeeded
-        end
+        parser = ResponseParser.new(raw_response, options)
+        parser.generate_response
+      end
 
-        Response.new(succeeded, message, parsed, options)
+      def parse_reponse(response)
+        JSON.parse(response.sub(/jsonPFunction\(/, '').sub(/\)\z/, ''))
       end
 
       def save_card_url
@@ -183,6 +174,47 @@ module ActiveMerchant #:nodoc:
       def transaction_id(authorization)
         authorization.split(';').first
       end
+
+      class ResponseParser
+        def initialize(raw_response="", options={})
+          @raw_response = raw_response
+          @options = options
+        end
+
+        def generate_response
+          parse_response
+          if parsed['error']
+            handle_response_parse_error
+          else
+            handle_response_correct_parsing
+          end
+
+          Response.new(succeeded, message, parsed, options)
+        end
+
+        private
+        attr_reader :raw_response, :parsed, :succeeded, :message, :options
+
+        def parse_response
+          @parsed = JSON.parse(raw_response.sub(/jsonPFunction\(/, '').sub(/\)\z/, ''))
+        end
+
+        def handle_response_parse_error
+          @succeeded = false
+          @message = parsed['error']['message']
+        end
+
+        def handle_response_correct_parsing
+          @message = parsed['transaction']['processing']['return']['message']
+          if @succeeded = is_ack?
+            @options[:authorization] = parsed['transaction']['identification']['uniqueId']
+          end
+        end
+
+        def is_ack?
+          parsed['transaction']['processing']['result'] == 'ACK'
+        end
+      end
     end
   end
 end

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

@@ -12,7 +12,7 @@ module ActiveMerchant #:nodoc:
       # This transaction creates a recurring payment profile
       # ==== Parameters
       #
-      # * <tt>money</tt> -- The amount to be charged to the customer at each interval as an Integer value in cents.
+      # * <tt>amount</tt> -- The amount to be charged to the customer at each interval as an Integer value in cents.
       # * <tt>credit_card</tt> -- The CreditCard details for the transaction.
       # * <tt>options</tt> -- A hash of parameters.
       #

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

@@ -108,8 +108,10 @@ module ActiveMerchant #:nodoc:
       def build_purchase_request(money, credit_card, options)
         xml = Builder::XmlMarkup.new
 
-        xml.tag! 'amount', amount(money)
-        xml.tag! 'currency', options[:currency] || currency(money)
+        currency = options[:currency] || currency(money)
+
+        xml.tag! 'amount', localized_amount(money, currency)
+        xml.tag! 'currency', currency
         xml.tag! 'purchaseOrderNo', options[:order_id].to_s.gsub(/[ ']/, '')
 
         xml.tag! 'CreditCardInfo' do

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

@@ -93,7 +93,8 @@ module ActiveMerchant #:nodoc:
       # credit_card    - The CreditCard to store
       # options        - A standard ActiveMerchant options hash
       def store(credit_card, options={})
-        save_card(true, credit_card, options)
+        retain = (options.has_key?(:retain) ? options[:retain] : true)
+        save_card(retain, credit_card, options)
       end
 
       # Public: Redact the CreditCard in Spreedly. This wipes the sensitive
@@ -118,7 +119,7 @@ module ActiveMerchant #:nodoc:
 
       def purchase_with_token(money, payment_method_token, options)
         request = auth_purchase_request(money, payment_method_token, options)
-        commit("gateways/#{@options[:gateway_token]}/purchase.xml", request)
+        commit("gateways/#{options[:gateway_token] || @options[:gateway_token]}/purchase.xml", request)
       end
 
       def authorize_with_token(money, payment_method_token, options)
@@ -137,6 +138,7 @@ module ActiveMerchant #:nodoc:
       def add_invoice(doc, money, options)
         doc.amount amount(money)
         doc.currency_code(options[:currency] || currency(money) || default_currency)
+        doc.order_id(options[:order_id])
       end
 
       def add_credit_card(doc, credit_card, options)

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

@@ -40,7 +40,7 @@ module ActiveMerchant #:nodoc:
         post = create_post_for_auth_or_purchase(money, creditcard, options)
         post[:capture] = "false"
 
-        commit(:post, 'charges', post, generate_meta(options))
+        commit(:post, 'charges', post, generate_options(options))
       end
 
       # To create a charge on a card or a token, call
@@ -53,7 +53,7 @@ module ActiveMerchant #:nodoc:
       def purchase(money, creditcard, options = {})
         post = create_post_for_auth_or_purchase(money, creditcard, options)
 
-        commit(:post, 'charges', post, generate_meta(options))
+        commit(:post, 'charges', post, generate_options(options))
       end
 
       def capture(money, authorization, options = {})
@@ -69,7 +69,7 @@ module ActiveMerchant #:nodoc:
 
       def refund(money, identification, options = {})
         post = {:amount => amount(money)}
-        commit_options = generate_meta(options)
+        commit_options = generate_options(options)
 
         MultiResponse.run(:first) do |r|
           r.process { commit(:post, "charges/#{CGI.escape(identification)}/refund", post, commit_options) }
@@ -97,28 +97,42 @@ module ActiveMerchant #:nodoc:
         commit(:post, "application_fees/#{CGI.escape(identification)}/refund", post, options)
       end
 
+      # Note: creating a new credit card will not change the customer's existing default credit card (use :set_default => true)
       def store(creditcard, options = {})
         post = {}
         add_creditcard(post, creditcard, options)
         post[:description] = options[:description]
         post[:email] = options[:email]
 
-        path = if options[:customer]
-          "customers/#{CGI.escape(options[:customer])}"
+        commit_options = generate_options(options)
+        if options[:customer]
+          MultiResponse.run(:first) do |r|
+            r.process { commit(:post, "customers/#{CGI.escape(options[:customer])}/cards", post, commit_options) }
+
+            return r unless options[:set_default] and r.success? and !r.params["id"].blank?
+
+            r.process { update_customer(options[:customer], :default_card => r.params["id"]) }
+          end
         else
-          'customers'
+          commit(:post, 'customers', post, commit_options)
         end
-
-        commit(:post, path, post, generate_meta(options))
       end
 
       def update(customer_id, creditcard, options = {})
-        options = options.merge(:customer => customer_id)
+        options = options.merge(:customer => customer_id, :set_default => true)
         store(creditcard, options)
       end
 
-      def unstore(customer_id, options = {})
-        commit(:delete, "customers/#{CGI.escape(customer_id)}", nil, generate_meta(options))
+      def update_customer(customer_id, options = {})
+        commit(:post, "customers/#{CGI.escape(customer_id)}", options, generate_options(options))
+      end
+
+      def unstore(customer_id, card_id = nil, options = {})
+        if card_id.nil?
+          commit(:delete, "customers/#{CGI.escape(customer_id)}", nil, generate_options(options))
+        else
+          commit(:delete, "customers/#{CGI.escape(customer_id)}/cards/#{CGI.escape(card_id)}", nil, generate_options(options))
+        end
       end
 
       private
@@ -145,7 +159,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_customer_data(post, options)
-        metadata_options = [:description,:browser_ip,:user_agent,:referrer]
+        metadata_options = [:description, :ip, :user_agent, :referrer]
         post.update(options.slice(*metadata_options))
 
         post[:external_id] = options[:order_id]
@@ -224,6 +238,11 @@ module ActiveMerchant #:nodoc:
         end.compact.join("&")
       end
 
+      def generate_options(raw_options)
+        options = generate_meta(raw_options)
+        options.merge!(raw_options.slice(:version))
+      end
+
       def generate_meta(options)
         {:meta => {:ip => options[:ip]}}
       end
@@ -234,18 +253,19 @@ module ActiveMerchant #:nodoc:
           :lang => 'ruby',
           :lang_version => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
           :platform => RUBY_PLATFORM,
-          :publisher => 'active_merchant',
-          :uname => (RUBY_PLATFORM =~ /linux|darwin/i ? `uname -a 2>/dev/null`.strip : nil)
+          :publisher => 'active_merchant'
         })
 
         key = options[:key] || @api_key
 
-        {
+        headers = {
           "Authorization" => "Basic " + Base64.encode64(key.to_s + ":").strip,
           "User-Agent" => "Stripe/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
           "X-Stripe-Client-User-Agent" => @@ua,
           "X-Stripe-Client-User-Metadata" => options[:meta].to_json
         }
+        headers.merge!("Stripe-Version" => options[:version]) if options[:version]
+        headers
       end
 
       def commit(method, url, parameters=nil, options = {})