merb_merchant 1.4.1

data/lib/merb_merchant/billing/gateways/braintree.rb

@@ -0,0 +1,222 @@
+require File.join(File.dirname(__FILE__), '..', 'check.rb')
+
+module MerbMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BraintreeGateway < Gateway
+      URL = 'https://secure.braintreepaymentgateway.com/api/transact.php'
+    
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.braintreepaymentsolutions.com'
+      self.display_name = 'Braintree'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end  
+      
+      # Pass :store => true in the options to store the 
+      # payment info at BrainTree and get a generated 
+      # customer_vault_id in the response.  
+      # Pass :store => some_number_or_string to specify the
+      # customer_vault_id BrainTree should use (make sure it's
+      # unique).
+      def authorize(money, payment_source, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, payment_source, options)        
+        add_address(post, payment_source, options)        
+        add_customer_data(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, payment_source, options)   
+        add_customer_data(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
+      
+      # Update the values (such as CC expiration) stored at
+      # BrainTree.  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, creditcard, options)   
+        add_customer_data(post, options)
+             
+        commit(nil, 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 = {})
+        billing_id = options.delete(:billing_id).to_s || true
+        post = {}
+        post[:customer_vault] = 'add_customer'
+        if billing_id
+          post[:customer_vault_id] = billing_id
+        end
+        add_payment_source(post, payment_source, options)
+        add_address(post, payment_source, options)
+        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, creditcard, options)     
+        if address = options[:billing_address] || options[:address]
+          post[:address1]    = address[:address1].to_s
+          post[:address2]    = address[:address2].to_s unless address[:address2].blank?
+          post[:company]    = address[:company].to_s
+          post[:phone]      = address[:phone].to_s
+          post[:zip]        = address[:zip].to_s       
+          post[:city]       = address[:city].to_s
+          post[:country]    = address[:country].to_s
+          post[:state]      = address[:state].blank?  ? 'n/a' : address[:state]
+        end         
+      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)
+        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)
+        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 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(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("%.4i", creditcard.year)
+        month = sprintf("%.2i", creditcard.month)
+
+        "#{month}#{year[-2..-1]}"
+      end
+      
+
+      def message_from(response)
+        case response["responsetext"]
+        when "SUCCESS","Approved"
+          "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
+    
+    BrainTreeGateway = BraintreeGateway
+  end
+end
+

data/lib/merb_merchant/billing/gateways/card_stream.rb

@@ -0,0 +1,229 @@
+module MerbMerchant #:nodoc:
+  module Billing #:nodoc:
+    #
+    # CardStream supports the following credit cards, which are auto-detected by
+    # the gateway based on the card number used: 
+    # * AM American Express 
+    # * Diners Club 
+    # * Electron 
+    # * JCB 
+    # * UK Maestro 
+    # * Maestro International 
+    # * Mastercard 
+    # * Solo 
+    # * Style 
+    # * Switch 
+    # * Visa Credit 
+    # * Visa Debit 
+    # * Visa Purchasing 
+    #
+    class CardStreamGateway < Gateway
+      URL = 'https://gateway.cardstream.com/process.ashx'
+      
+      self.money_format = :cents
+      self.default_currency = 'GBP'
+      self.supported_countries = ['GB']
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :discover, :jcb, :maestro, :solo, :switch]
+      self.homepage_url = 'http://www.cardstream.com/'
+      self.display_name = 'CardStream'
+
+      APPROVED = '00'
+
+      CURRENCY_CODES = { 
+        "AUD"=> '036',
+        "CAD"=> '124',
+        "CZK"=> '203',
+        "DKK"=> '208',
+        "HKD"=> '344',
+        "ICK"=> '352',
+        "JPY"=> '392',
+        "NOK"=> '578',
+        "SGD"=> '702',
+        "SEK"=> '752',
+        "CHF"=> '756',
+        "GBP"=> '826',
+        "USD"=> '840',
+        "EUR"=> '978'
+      }
+      
+      TRANSACTIONS = {
+        :purchase => 'ESALE_KEYED',
+        :refund => 'EREFUND_KEYED',
+        :authorization => 'ESALE_KEYED'
+      }
+      
+      CVV_CODE = {
+        '0' => 'U',  
+        '1' => 'P',
+        '2' => 'M',
+        '4' => 'N'
+      }
+      
+      # 0 - No additional information available.  
+      # 1 - Postcode not checked.  
+      # 2 - Postcode matched.  
+      # 4 - Postcode not matched.  
+      # 8 - Postcode partially matched.
+      AVS_POSTAL_MATCH = {
+        "0" => nil,
+        "1" => nil,
+        "2" => "Y",
+        "4" => "N",
+        "8" => "N"
+      }
+      
+      # 0 - No additional information available.  
+      # 1 - Address numeric not checked.  
+      # 2 - Address numeric matched.  
+      # 4 - Address numeric not matched.  
+      # 8 - Address numeric partially matched.
+      AVS_STREET_MATCH = {
+        "0" => nil,
+        "1" => nil,
+        "2" => "Y",
+        "4" => "N",
+        "8" => "N"
+      }
+      
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end
+
+      def purchase(money, credit_card, options = {})
+        requires!(options, :order_id)
+        
+        post = {}
+        
+        add_amount(post, money, options)
+        add_invoice(post, money, credit_card, options)
+        add_credit_card(post, credit_card)
+        add_address(post, options)
+        add_customer_data(post, options)
+
+        commit(:purchase, post)
+      end
+  
+      private
+      
+      def add_amount(post, money, options)
+        add_pair(post, :Amount, amount(money), :required => true)
+        add_pair(post, :CurrencyCode, currency_code(options[:currency] || currency(money)), :required => true)
+      end
+
+      def add_customer_data(post, options)
+        add_pair(post, :BillingEmail, options[:email])
+        add_pair(post, :BillingPhoneNumber, options[:phone])
+      end
+
+      def add_address(post, options)
+        address = options[:billing_address] || options[:address]
+        
+        return if address.nil?
+
+        add_pair(post, :BillingStreet, address[:address1])
+        add_pair(post, :BillingHouseNumber, address[:address2])
+        add_pair(post, :BillingCity, address[:city])
+        add_pair(post, :BillingState, address[:state])
+        add_pair(post, :BillingPostCode, address[:zip])
+      end
+
+      def add_invoice(post, money, credit_card, options)
+        add_pair(post, :TransactionUnique, options[:order_id], :required => true)
+        add_pair(post, :OrderDesc, options[:description] || options[:order_id], :required => true)
+        
+        if [ 'american_express', 'diners_club' ].include?(card_brand(credit_card).to_s)
+          add_pair(post, :AEIT1Quantity,  1) 
+          add_pair(post, :AEIT1Description,  (options[:description] || options[:order_id]).slice(0, 15)) 
+          add_pair(post, :AEIT1GrossValue, amount(money))
+        end
+      end
+
+      def add_credit_card(post, credit_card)
+        add_pair(post, :CardName, credit_card.name, :required => true)
+        add_pair(post, :CardNumber, credit_card.number, :required => true)
+         
+        add_pair(post, :ExpiryDateMM, format(credit_card.month, :two_digits), :required => true)
+        add_pair(post, :ExpiryDateYY, format(credit_card.year, :two_digits), :required => true)
+         
+        if requires_start_date_or_issue_number?(credit_card)
+          add_pair(post, :StartDateMM, format(credit_card.start_month, :two_digits))
+          add_pair(post, :StartDateYY, format(credit_card.start_year, :two_digits))
+          
+          add_pair(post, :IssueNumber, credit_card.issue_number)
+        end
+        
+        add_pair(post, :CV2, credit_card.verification_value)
+      end
+      
+      def commit(action, parameters)
+        response = parse( ssl_post(URL, post_data(action, parameters)) )
+
+        Response.new(response[:response_code] == APPROVED, message_from(response), response,
+          :test => test?,
+          :authorization => response[:cross_reference],
+          :cvv_result => CVV_CODE[ response[:avscv2_response_code].to_s[0, 1] ],
+          :avs_result => {
+            :street_match => AVS_STREET_MATCH[ response[:avscv2_response_code].to_s[2, 1] ],
+            :postal_match => AVS_POSTAL_MATCH[ response[:avscv2_response_code].to_s[1, 1] ]
+          }
+        )
+      end
+
+      def message_from(results)
+        results[:response_code] == APPROVED ? "APPROVED" : results[:message]
+      end
+
+      def post_data(action, parameters = {})
+        parameters.update(
+          :MerchantPassword => @options[:password],
+          :MerchantID => @options[:login],
+          :MessageType => TRANSACTIONS[action],
+          :CallBack => "disable",
+          :DuplicateDelay => "0",
+          :EchoCardType => "YES",
+          :EchoAmount => "YES",
+          :EchoAVSCV2ResponseCode => "YES",
+          :ReturnAVSCV2Message => "YES",
+          :CountryCode => '826' # 826 for UK based merchant
+        )
+        
+        add_pair(parameters, :Dispatch, action == :authorization ? "LATER" : "NOW")
+    
+        parameters.collect { |key, value| "VP#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+      
+      # VPCrossReference 
+      # The value in VPCrossReference on a success transaction will contain 
+      # a unique reference that you may use to run future transactions. 
+      # Please note that cross reference transactions must come a static IP 
+      # addressed that has been pre-registered with Cardstream. To 
+      # register an IP address please send it to support@cardstream.com 
+      # with your Cardstream issued merchant ID and it will be added to 
+      # your account.
+      def parse(body)
+        result = {}
+        pairs = body.split("&")
+        pairs.each do |pair|
+          a = pair.split("=")
+          result[MerbMerchant::Inflector.underscore(a[0].gsub(/^VP/,'')).to_sym] = a[1]
+        end
+        result
+      end
+
+      def test?
+        @options[:test] || Base.gateway_mode == :test
+      end
+      
+      def currency_code(currency)
+        CURRENCY_CODES[currency]
+      end
+
+      def add_pair(post, key, value, options = {})
+        post[key] = value if !value.blank? || options[:required]
+      end
+    end
+  end
+end
+