activemerchant 1.15.0 → 1.16.0

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

@@ -1,5 +1,3 @@
-require 'securerandom'
-
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class QbmsGateway < Gateway
@@ -118,7 +116,7 @@ module ActiveMerchant #:nodoc:
       end
 
       private
-      
+
       def hosted?
         @options[:pem]
       end

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

@@ -6,50 +6,51 @@ module ActiveMerchant #:nodoc:
     class QuickpayGateway < Gateway
       URL = 'https://secure.quickpay.dk/api'
 
-      self.default_currency = 'DKK'  
+      self.default_currency = 'DKK'
       self.money_format = :cents
       self.supported_cardtypes = [ :dankort, :forbrugsforeningen, :visa, :master, :american_express, :diners_club, :jcb, :maestro ]
       self.supported_countries = ['DK', 'SE']
       self.homepage_url = 'http://quickpay.dk/'
       self.display_name = 'Quickpay'
-      
+
       PROTOCOL = 3
-      
+
       MD5_CHECK_FIELDS = {
-        :authorize => [:protocol, :msgtype, :merchant, :ordernumber, :amount, :currency, :autocapture, :cardnumber, :expirationdate, :cvd, :cardtypelock],
+        :authorize => [:protocol, :msgtype, :merchant, :ordernumber, :amount, :currency, :autocapture, :cardnumber, :expirationdate, :cvd, :cardtypelock, :testmode],
         :capture   => [:protocol, :msgtype, :merchant, :amount, :transaction],
         :cancel    => [:protocol, :msgtype, :merchant, :transaction],
         :refund    => [:protocol, :msgtype, :merchant, :amount, :transaction],
-        :subscribe => [:protocol, :msgtype, :merchant, :ordernumber, :cardnumber, :expirationdate, :cvd, :cardtypelock, :description],
+        :subscribe => [:protocol, :msgtype, :merchant, :ordernumber, :cardnumber, :expirationdate, :cvd, :cardtypelock, :description, :testmode],
         :recurring => [:protocol, :msgtype, :merchant, :ordernumber, :amount, :currency, :autocapture, :transaction],
         :status    => [:protocol, :msgtype, :merchant, :transaction],
         :chstatus  => [:protocol, :msgtype, :merchant],
       }
-      
+
       APPROVED = '000'
-      
+
       # The login is the QuickpayId
       # The password is the md5checkword from the Quickpay admin interface
       def initialize(options = {})
         requires!(options, :login, :password)
         @options = options
         super
-      end  
-      
+      end
+
       def authorize(money, credit_card_or_reference, options = {})
         post = {}
-        
+
         add_amount(post, money, options)
         add_invoice(post, options)
         add_creditcard_or_reference(post, credit_card_or_reference, options)
         add_autocapture(post, false)
+        add_testmode(post)
 
         commit(recurring_or_authorize(credit_card_or_reference), post)
       end
-            
+
       def purchase(money, credit_card_or_reference, options = {})
         post = {}
-        
+
         add_amount(post, money, options)
         add_creditcard_or_reference(post, credit_card_or_reference, options)
         add_invoice(post, options)
@@ -57,24 +58,24 @@ module ActiveMerchant #:nodoc:
 
         commit(recurring_or_authorize(credit_card_or_reference), post)
       end
-      
+
       def capture(money, authorization, options = {})
         post = {}
-        
+
         add_reference(post, authorization)
         add_amount_without_currency(post, money)
-        
+
         commit(:capture, post)
       end
-      
+
       def void(identification, options = {})
         post = {}
-        
+
         add_reference(post, identification)
-        
+
         commit(:cancel, post)
       end
-      
+
       def refund(money, identification, options = {})
         post = {}
 
@@ -86,57 +87,58 @@ module ActiveMerchant #:nodoc:
 
       def credit(money, identification, options = {})
         deprecated CREDIT_DEPRECATION_MESSAGE
-        refund(money, identification, options)      
+        refund(money, identification, options)
       end
-      
-      def store(creditcard, options = {})                       
+
+      def store(creditcard, options = {})
         post = {}
-        
+
         add_creditcard(post, creditcard, options)
         add_invoice(post, options)
         add_description(post, options)
+        add_testmode(post)
 
         commit(:subscribe, post)
       end
-      
-      private                       
-  
+
+      private
+
       def add_amount(post, money, options = {})
         post[:amount]   = amount(money)
         post[:currency] = options[:currency] || currency(money)
       end
-      
+
       def add_amount_without_currency(post, money, options = {})
         post[:amount] = amount(money)
       end
-      
+
       def add_invoice(post, options)
         post[:ordernumber] = format_order_number(options[:order_id])
       end
-      
+
       def add_creditcard(post, credit_card, options)
-        post[:cardnumber]     = credit_card.number   
+        post[:cardnumber]     = credit_card.number
         post[:cvd]            = credit_card.verification_value
         post[:expirationdate] = expdate(credit_card)
         post[:cardtypelock]   = options[:cardtypelock] unless options[:cardtypelock].blank?
       end
-      
+
       def add_reference(post, identification)
         post[:transaction] = identification
       end
-      
+
       def add_creditcard_or_reference(post, credit_card_or_reference, options)
         if credit_card_or_reference.is_a?(String)
           add_reference(post, credit_card_or_reference)
         else
           add_creditcard(post, credit_card_or_reference, options)
         end
-      end        
-      
+      end
+
       def add_autocapture(post, autocapture)
         post[:autocapture] = autocapture ? 1 : 0
       end
-      
+
       def recurring_or_authorize(credit_card_or_reference)
         credit_card_or_reference.is_a?(String) ? :recurring : :authorize
       end
@@ -144,29 +146,33 @@ module ActiveMerchant #:nodoc:
       def add_description(post, options)
         post[:description] = options[:description]
       end
-      
+
+      def add_testmode(post)
+        post[:testmode] = test? ? '1' : '0'
+      end
+
       def commit(action, params)
         response = parse(ssl_post(URL, post_data(action, params)))
-        
-        Response.new(successful?(response), message_from(response), response, 
-          :test => test?, 
+
+        Response.new(successful?(response), message_from(response), response,
+          :test => test?,
           :authorization => response[:transaction]
         )
       end
-      
+
       def successful?(response)
         response[:qpstat] == APPROVED
       end
 
       def parse(data)
         response = {}
-        
+
         doc = REXML::Document.new(data)
-        
+
         doc.root.elements.each do |element|
           response[element.name.to_sym] = element.text
         end
-        
+
         response
       end
 
@@ -175,39 +181,38 @@ module ActiveMerchant #:nodoc:
         when '008'   # Error in request data
           response[:qpstatmsg].to_s
           #.scan(/[A-Z][a-z0-9 \/]+/).to_sentence
-        else          
+        else
           response[:qpstatmsg].to_s
         end
       end
-      
+
       def post_data(action, params = {})
         params[:protocol] = PROTOCOL
         params[:msgtype]  = action.to_s
         params[:merchant] = @options[:login]
-        #params[:testmode] = '1' if test?
         params[:md5check] = generate_check_hash(action, params)
-        
+
         params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
       end
-  
+
       def generate_check_hash(action, params)
         string = MD5_CHECK_FIELDS[action].collect do |key|
           params[key]
         end.join('')
-        
+
         # Add the md5checkword
         string << @options[:password].to_s
 
         Digest::MD5.hexdigest(string)
       end
-      
+
       def expdate(credit_card)
         year  = format(credit_card.year, :two_digits)
         month = format(credit_card.month, :two_digits)
 
         "#{year}#{month}"
       end
-      
+
       # Limited to 20 digits max
       def format_order_number(number)
         number.to_s.gsub(/[^\w_]/, '').rjust(4, "0")[0...20]

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

@@ -0,0 +1,212 @@
+require 'json'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class StripeGateway < Gateway
+      LIVE_URL = 'https://api.stripe.com/v1/'
+
+      AVS_CODE_TRANSLATOR = {
+        'line1: pass, zip: pass' => 'Y',
+        'line1: pass, zip: fail' => 'A',
+        'line1: pass, zip: unchecked' => 'B',
+        'line1: fail, zip: pass' => 'Z',
+        'line1: fail, zip: fail' => 'N',
+        'line1: unchecked, zip: pass' => 'P',
+        'line1: unchecked, zip: unchecked' => 'I'
+      }
+
+      CVC_CODE_TRANSLATOR = {
+        'pass' => 'M',
+        'fail' => 'N',
+        'unchecked' => 'P'
+      }
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+
+      self.homepage_url = 'https://stripe.com/'
+      self.display_name = 'Stripe'
+
+      def initialize(options = {})
+        requires!(options, :login)
+        @api_key = options[:login]
+        super
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_creditcard(post, creditcard, options)
+        add_customer(post, options)
+        add_customer_data(post, options)
+        add_flags(post, options)
+
+        raise ArgumentError.new("Customer or Credit Card required.") if !post[:card] && !post[:customer]
+
+        commit('charges', post)
+      end
+
+      def authorize(money, creditcard, options = {})
+        purchase(money, creditcard, options.merge(:uncaptured => true))
+      end
+
+      def capture(money, identification, options = {})
+        commit("charges/#{CGI.escape(identification)}/capture", {})
+      end
+
+      def void(identification, options={})
+        commit("charges/#{CGI.escape(identification)}/refund", {})
+      end
+
+      def refund(money, identification, options = {})
+        post = {}
+
+        post[:amount] = amount(money) if money
+
+        commit("charges/#{CGI.escape(identification)}/refund", post)
+      end
+
+      def store(creditcard, options={})
+        post = {}
+        add_creditcard(post, creditcard, options)
+        add_customer_data(post, options)
+
+        if options[:customer]
+          commit("customers/#{CGI.escape(options[:customer])}", post)
+        else
+          commit('customers', post)
+        end
+      end
+
+      private
+
+      def add_amount(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money)).downcase
+      end
+
+      def add_customer_data(post, options)
+        post[:description] = options[:email] || options[:description]
+      end
+
+      def add_address(post, options)
+        return unless post[:card] && post[:card].kind_of?(Hash)
+        if address = options[:billing_address] || options[:address]
+          post[:card][:address_line1] = address[:address1] if address[:address1]
+          post[:card][:address_line2] = address[:address2] if address[:address2]
+          post[:card][:address_country] = address[:country] if address[:country]
+          post[:card][:address_zip] = address[:zip] if address[:zip]
+          post[:card][:address_state] = address[:state] if address[:state]
+        end
+      end
+
+      def add_creditcard(post, creditcard, options)
+        if creditcard.respond_to?(:number)
+          card = {}
+          card[:number] = creditcard.number
+          card[:exp_month] = creditcard.month
+          card[:exp_year] = creditcard.year
+          card[:cvc] = creditcard.verification_value if creditcard.verification_value?
+          card[:name] = creditcard.name if creditcard.name
+          post[:card] = card
+
+          add_address(post, options)
+        elsif creditcard.kind_of?(String)
+          post[:card] = creditcard
+        end
+      end
+
+      def add_customer(post, options)
+        post[:customer] = options[:customer] if options[:customer] && !post[:card]
+      end
+
+      def add_flags(post, options)
+        post[:uncaptured] = true if options[:uncaptured]
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def post_data(params)
+        params.map do |key, value|
+          next if value.blank?
+          if value.is_a?(Hash)
+            h = {}
+            value.each do |k, v|
+              h["#{key}[#{k}]"] = v unless v.blank?
+            end
+            post_data(h)
+          else
+            "#{key}=#{CGI.escape(value.to_s)}"
+          end
+        end.compact.join("&")
+      end
+
+      def headers
+        @@ua ||= JSON.dump({
+          :bindings_version => ActiveMerchant::VERSION,
+          :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)
+        })
+
+        {
+          "Authorization" => "Basic " + ActiveSupport::Base64.encode64(@api_key.to_s + ":").strip,
+          "User-Agent" => "Stripe/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          "X-Stripe-Client-User-Agent" => @@ua
+        }
+      end
+
+      def commit(url, parameters, method=:post)
+        raw_response = response = nil
+        success = false
+        begin
+          raw_response = ssl_request(method, LIVE_URL + url, post_data(parameters), headers)
+          response = parse(raw_response)
+          success = !response.key?("error")
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response = response_error(raw_response)
+        rescue JSON::ParserError
+          response = json_error(raw_response)
+        end
+
+        card = response["card"] || {}
+        avs_code = AVS_CODE_TRANSLATOR["line1: #{card["address_line1_check"]}, zip: #{card["address_zip_check"]}"]
+        cvc_code = CVC_CODE_TRANSLATOR[card["cvc_check"]]
+        Response.new(success,
+          success ? "Transaction approved" : response["error"]["message"],
+          response,
+          :test => !response["livemode"],
+          :authorization => response["id"],
+          :avs_result => { :code => avs_code },
+          :cvv_result => cvc_code
+        )
+      end
+
+      def response_error(raw_response)
+        begin
+          parse(raw_response)
+        rescue JSON::ParserError
+          json_error(raw_response)
+        end
+      end
+
+      def json_error(raw_response)
+        msg = 'Invalid response received from the Stripe API.  Please contact support@stripe.com if you continue to receive this message.'
+        msg += "  (The raw response returned by the API was #{raw_response.inspect})"
+        {
+          "error" => {
+            "message" => msg
+          }
+        }
+      end
+    end
+  end
+end