tlconnor-activemerchant 1.20.4

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

@@ -0,0 +1,271 @@
+require File.join(File.dirname(__FILE__), '..', 'check.rb')
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SmartPs < Gateway #:nodoc:
+      
+      ##
+      # This is the base gateway for processors who use the smartPS processing system
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end  
+      
+      # Pass :store => true in the options to store the 
+      # payment info at the gateway and get a generated 
+      # customer_vault_id in the response.  
+      # Pass :store => some_number_or_string to specify the
+      # customer_vault_id the gateway should use (make sure it's
+      # unique).
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, creditcard,options)
+        add_address(post, options[:billing_address] || options[:address])
+        add_address(post, options[:shipping_address], "shipping")
+        add_customer_data(post, options)
+        add_currency(post, money, options)
+        add_taxes(post, options)
+        add_processor(post, options)
+        commit('auth', money, post)
+      end
+      
+      def purchase(money, payment_source, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, payment_source, options)
+        add_address(post, options[:billing_address] || options[:address])
+        add_address(post, options[:shipping_address], "shipping")
+        add_customer_data(post, options)
+        add_currency(post, money, options)
+        add_taxes(post, options)
+        add_processor(post, options)     
+        commit('sale', money, post)
+      end                       
+    
+      def capture(money, authorization, options = {})
+        post ={}
+        post[:transactionid] = authorization
+        commit('capture', money, post)
+      end
+      
+      def void(authorization, options = {})
+        post ={}
+        post[:transactionid] = authorization
+        commit('void', nil, post)
+      end
+      
+      def credit(money, payment_source, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, payment_source, options)        
+        add_address(post, options[:billing_address] || options[:address])
+        add_customer_data(post, options)
+        add_sku(post,options)
+        add_currency(post, money, options)
+        add_processor(post, options)
+        commit('credit', money, post)
+      end
+      
+      def refund(money, auth, options = {})
+        post = {}
+        add_transaction(post, auth)
+        commit('refund', money, post)
+      end
+      
+      
+      # Update the values (such as CC expiration) stored at
+      # the gateway.  The CC number must be supplied in the
+      # CreditCard object.
+      def update(vault_id, creditcard, options = {})
+        post = {}
+        post[:customer_vault] = "update_customer"
+        add_customer_vault_id(post, vault_id)
+        add_creditcard(post, creditcard, options)        
+        add_address(post, options[:billing_address] || options[:address])
+        add_customer_data(post, options)
+             
+        commit(nil, nil, post)
+      end
+      
+      # Amend an existing transaction
+      def amend(auth, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_transaction(post, auth)
+        commit('update', nil, post)
+      end
+      
+    
+      def delete(vault_id)
+        post = {}
+        post[:customer_vault] = "delete_customer"
+        add_customer_vault_id(post, vault_id)         
+        commit(nil, nil, post)
+      end
+    
+      # To match the other stored-value gateways, like TrustCommerce,
+      # store and unstore need to be defined
+      def store(payment_source, options = {})
+        post = {}
+        billing_id = options.delete(:billing_id).to_s || true
+        add_payment_source(post, payment_source, :store => billing_id)
+        add_address(post, options[:billing_address] || options[:address])
+        add_customer_data(post, options)
+        commit(nil, nil, post)
+      end
+      
+      alias_method :unstore, :delete
+
+      private                             
+      def add_customer_data(post, options)
+        if options.has_key? :email
+          post[:email] = options[:email]
+        end
+
+        if options.has_key? :ip
+          post[:ipaddress] = options[:ip]
+        end        
+      end
+
+      def add_address(post, address,prefix="")     
+        prefix +="_" unless prefix.blank? 
+        unless address.blank? or address.values.blank?
+          post[prefix+"address1"]    = address[:address1].to_s
+          post[prefix+"address2"]    = address[:address2].to_s unless address[:address2].blank?
+          post[prefix+"company"]    = address[:company].to_s
+          post[prefix+"phone"]      = address[:phone].to_s
+          post[prefix+"zip"]        = address[:zip].to_s       
+          post[prefix+"city"]       = address[:city].to_s
+          post[prefix+"country"]    = address[:country].to_s
+          post[prefix+"state"]      = address[:state].blank?  ? 'n/a' : address[:state]
+        end         
+      end
+      
+      def add_currency(post, money, options)
+        post[:currency] = options[:currency] || currency(money)
+      end
+
+      def add_taxes(post, options)
+        post[:tax] = amount(options[:tax])
+      end
+
+      def add_processor(post, options)
+        post[:processor] = options[:processor] unless options[:processor].nil?
+      end
+      
+      def add_invoice(post, options)
+        post[:orderid] = options[:order_id].to_s.gsub(/[^\w.]/, '')
+      end
+      
+      def add_payment_source(params, source, options={})
+        case determine_funding_source(source)
+        when :vault       then add_customer_vault_id(params, source)
+        when :credit_card then add_creditcard(params, source, options)
+        when :check       then add_check(params, source, options)
+        end
+      end
+      
+      def add_customer_vault_id(params, vault_id)
+        params[:customer_vault_id] = vault_id
+      end
+      
+      def add_creditcard(post, creditcard, options)
+        if options[:store]  
+          post[:customer_vault] = "add_customer"
+          post[:customer_vault_id] = options[:store] unless options[:store] == true
+        end
+        post[:ccnumber]  = creditcard.number
+        post[:cvv] = creditcard.verification_value if creditcard.verification_value?
+        post[:ccexp]  = expdate(creditcard)
+        post[:firstname] = creditcard.first_name
+        post[:lastname]  = creditcard.last_name   
+      end
+      
+      def add_check(post, check, options)
+        if options[:store]  
+          post[:customer_vault] = "add_customer"
+          post[:customer_vault_id] = options[:store] unless options[:store] == true
+        end
+        
+        post[:payment] = 'check' # Set transaction to ACH
+        post[:checkname] = check.name # The name on the customer's Checking Account
+        post[:checkaba] = check.routing_number # The customer's bank routing number
+        post[:checkaccount] = check.account_number # The customer's account number
+        post[:account_holder_type] = check.account_holder_type # The customer's type of ACH account
+        post[:account_type] = check.account_type # The customer's type of ACH account
+      end
+      
+      def add_sku(post,options)
+        post["product_sku_#"] = options[:sku] || options["product_sku_#"]
+      end
+      
+      def add_transaction(post, auth)
+        post[:transactionid] = auth
+      end
+      
+      def parse(body)
+        results = {}
+        body.split(/&/).each do |pair|
+          key,val = pair.split(/=/)
+          results[key] = val
+        end
+        
+        results
+      end     
+      
+      def commit(action, money, parameters)
+        parameters[:amount]  = amount(money) if money
+        response = parse( ssl_post(api_url, post_data(action,parameters)) )
+        Response.new(response["response"] == "1", message_from(response), response, 
+          :authorization => response["transactionid"],
+          :test => test?,
+          :cvv_result => response["cvvresponse"],
+          :avs_result => { :code => response["avsresponse"] }
+        )
+        
+      end
+      
+      def expdate(creditcard)
+        year  = sprintf("%.04i", creditcard.year.to_i)
+        month = sprintf("%.02i", creditcard.month.to_i)
+
+        "#{month}#{year[-2..-1]}"
+      end
+      
+
+      def message_from(response)
+        case response["responsetext"]
+        when "SUCCESS", "Approved", nil # This is dubious, but responses from UPDATE are nil.
+          "This transaction has been approved"
+        when "DECLINE"
+          "This transaction has been declined"
+        else
+          response["responsetext"]
+        end
+      end
+      
+      def post_data(action, parameters = {})
+        post = {}
+        post[:username]      = @options[:login]
+        post[:password]   = @options[:password]
+        post[:type]       = action if action
+
+        request = post.merge(parameters).map {|key,value| "#{key}=#{CGI.escape(value.to_s)}"}.join("&")
+        request        
+      end
+      
+      def determine_funding_source(source)
+        case 
+        when source.is_a?(String) then :vault
+        when CreditCard.card_companies.keys.include?(card_brand(source)) then :credit_card
+        when card_brand(source) == 'check' then :check
+        else raise ArgumentError, "Unsupported funding source provided"
+        end
+      end
+    end    
+  end
+end
+

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

@@ -0,0 +1,244 @@
+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
+
+      # To create a charge on a card or a token, call
+      #
+      #   purchase(money, card_hash_or_token, { ... })
+      #
+      # To create a charge on a customer, call
+      #
+      #   purchase(money, nil, { :customer => id, ... })
+      def purchase(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_creditcard(post, creditcard, options)
+        add_customer(post, options)
+        post[:description] = options[:description] || options[:email]
+        add_flags(post, options)
+
+        meta = generate_meta(options)
+
+        raise ArgumentError.new("Customer or Credit Card required.") if !post[:card] && !post[:customer]
+
+        commit(:post, 'charges', post, meta)
+      end
+
+      def authorize(money, creditcard, options = {})
+        raise "Stripe does not support separate authorization and capture"
+      end
+
+      def capture(money, identification, options = {})
+        raise "Stripe does not support separate authorization and capture"
+      end
+
+      def void(identification, options = {})
+        commit(:post, "charges/#{CGI.escape(identification)}/refund", {})
+      end
+
+      def refund(money, identification, options = {})
+        meta = generate_meta(options)
+        post = {}
+
+        post[:amount] = amount(money) if money
+
+        commit(:post, "charges/#{CGI.escape(identification)}/refund", post, meta)
+      end
+
+      def store(creditcard, options = {})
+        post = {}
+        add_creditcard(post, creditcard, options)
+        post[:description] = options[:description]
+        post[:email] = options[:email]
+
+        meta = generate_meta(options)
+        path = if options[:customer]
+          "customers/#{CGI.escape(options[:customer])}"
+        else
+          'customers'
+        end
+
+        commit(:post, path, post, meta)
+      end
+
+      def update(customer_id, creditcard, options = {})
+        options = options.merge(:customer => customer_id)
+        store(creditcard, options)
+      end
+
+      def unstore(customer_id, options = {})
+        meta = generate_meta(options)
+        commit(:delete, "customers/#{CGI.escape(customer_id)}", nil, meta)
+      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[:description]
+        post[:email] = options[:email]
+      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)
+        return nil unless 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 generate_meta(options)
+        {:ip => options[:ip]}
+      end
+
+      def headers(meta={})
+        @@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 " + Base64.encode64(@api_key.to_s + ":").strip,
+          "User-Agent" => "Stripe/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          "X-Stripe-Client-User-Agent" => @@ua,
+          "X-Stripe-Client-User-Metadata" => meta.to_json
+        }
+      end
+
+      def commit(method, url, parameters=nil, meta={})
+        raw_response = response = nil
+        success = false
+        begin
+          raw_response = ssl_request(method, LIVE_URL + url, post_data(parameters), headers(meta))
+          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"] || response["active_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