maedana-activemerchant 1.9.1.1

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

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/braintree/braintree_common'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BraintreeGateway < Gateway
+      include BraintreeCommon
+      
+      def self.new(options={})
+        if options.has_key?(:login)
+          BraintreeOrangeGateway.new(options)
+        else
+          BraintreeBlueGateway.new(options)
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/braintree/braintree_common.rb

@@ -0,0 +1,9 @@
+module BraintreeCommon
+  def self.included(base)
+    base.supported_countries = ['US']
+    base.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb]
+    base.homepage_url = 'http://www.braintreepaymentsolutions.com'
+    base.display_name = 'Braintree'
+    base.default_currency = 'USD'
+  end
+end

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

@@ -0,0 +1,210 @@
+require File.dirname(__FILE__) + '/braintree/braintree_common'
+
+begin
+  require "braintree"
+rescue LoadError
+  raise "Could not load the braintree gem.  Use `gem install braintree` to install it."
+end
+
+raise "Need braintree gem 2.x.y. Run `gem install braintree --version '~>2.0'` to get the correct version." unless Braintree::Version::Major == 2
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BraintreeBlueGateway < Gateway
+      include BraintreeCommon
+      
+      self.display_name = 'Braintree (Blue Platform)'
+
+      def initialize(options = {})
+        requires!(options, :merchant_id, :public_key, :private_key)
+        @options = options
+        Braintree::Configuration.merchant_id = options[:merchant_id]
+        Braintree::Configuration.public_key = options[:public_key]
+        Braintree::Configuration.private_key = options[:private_key]
+        Braintree::Configuration.environment = test? ? :sandbox : :production
+        Braintree::Configuration.logger.level = Logger::ERROR if Braintree::Configuration.logger
+        Braintree::Configuration.custom_user_agent = "ActiveMerchant #{ActiveMerchant::VERSION}"
+        super
+      end
+
+      def authorize(money, credit_card_or_vault_id, options = {})
+        create_transaction(:sale, money, credit_card_or_vault_id, options)
+      end
+
+      def capture(money, authorization, options = {})
+        commit do
+          result = Braintree::Transaction.submit_for_settlement(authorization, amount(money).to_s)
+          Response.new(result.success?, message_from_result(result))
+        end
+      end
+
+      def purchase(money, credit_card_or_vault_id, options = {})
+        authorize(money, credit_card_or_vault_id, options.merge(:submit_for_settlement => true))
+      end
+
+      def credit(money, credit_card_or_vault_id, options = {})
+        create_transaction(:credit, money, credit_card_or_vault_id, options)
+      end
+
+      def refund(transaction_id, options = {})
+        commit do
+          result = Braintree::Transaction.find(transaction_id).refund
+          Response.new(result.success?, message_from_result(result))
+        end
+      end
+
+      def void(authorization, options = {})
+        commit do
+          result = Braintree::Transaction.void(authorization)
+          Response.new(result.success?, message_from_result(result),
+            :braintree_transaction => (result.transaction if result.success?)
+          )
+        end
+      end
+
+      def store(creditcard, options = {})
+        commit do
+          result = Braintree::Customer.create(
+            :first_name => creditcard.first_name,
+            :last_name => creditcard.last_name,
+            :email => options[:email],
+            :credit_card => {
+              :number => creditcard.number,
+              :cvv => creditcard.verification_value,
+              :expiration_month => creditcard.month.to_s.rjust(2, "0"),
+              :expiration_year => creditcard.year.to_s
+            }
+          )
+          Response.new(result.success?, message_from_result(result),
+            {
+              :braintree_customer => (result.customer if result.success?),
+              :customer_vault_id => (result.customer.id if result.success?)
+            }
+          )
+        end
+      end
+
+      def update(vault_id, creditcard, options = {})
+        braintree_credit_card = nil
+        customer_update_result = commit do
+          braintree_credit_card = Braintree::Customer.find(vault_id).credit_cards.detect { |cc| cc.default? }
+          return Response.new(false, 'Braintree::NotFoundError') if braintree_credit_card.nil?
+          result = Braintree::Customer.update(vault_id,
+            :first_name => creditcard.first_name,
+            :last_name => creditcard.last_name,
+            :email => options[:email]
+          )
+          Response.new(result.success?, message_from_result(result),
+            :braintree_customer => (Braintree::Customer.find(vault_id) if result.success?)
+          )
+        end
+        return customer_update_result unless customer_update_result.success?
+        credit_card_update_result = commit do
+          result = Braintree::CreditCard.update(braintree_credit_card.token,
+              :number => creditcard.number,
+              :expiration_month => creditcard.month.to_s.rjust(2, "0"),
+              :expiration_year => creditcard.year.to_s
+          )
+          Response.new(result.success?, message_from_result(result),
+            :braintree_customer => (Braintree::Customer.find(vault_id) if result.success?)
+          )
+        end
+      end
+
+      def unstore(customer_vault_id)
+        commit do
+          Braintree::Customer.delete(customer_vault_id)
+          Response.new(true, "OK")
+        end
+      end
+      alias_method :delete, :unstore
+
+      private
+
+      def map_address(address)
+        return {} if address.nil?
+        {
+          :street_address => address[:address1],
+          :extended_address => address[:address2],
+          :company => address[:company],
+          :locality => address[:city],
+          :region => address[:state],
+          :postal_code => address[:zip],
+          :country_name => address[:country]
+        }
+      end
+
+      def commit(&block)
+        yield
+      rescue Braintree::BraintreeError => ex
+        Response.new(false, ex.class.to_s)
+      end
+
+      def message_from_result(result)
+        if result.success?
+          "OK"
+        else
+          result.errors.map { |e| "#{e.message} (#{e.code})" }.join(" ")
+        end
+      end
+
+      def create_transaction(transaction_type, money, credit_card_or_vault_id, options)
+        parameters = {
+          :amount => amount(money).to_s,
+          :order_id => options[:order_id],
+          :customer => {
+            :id => options[:store] == true ? "" : options[:store],
+            :email => options[:email]
+          },
+          :options => {
+            :store_in_vault => options[:store] ? true : false,
+            :submit_for_settlement => options[:submit_for_settlement]
+          }
+        }
+        if credit_card_or_vault_id.is_a?(String) || credit_card_or_vault_id.is_a?(Integer)
+          parameters[:customer_id] = credit_card_or_vault_id
+        else
+          parameters[:customer].merge!(
+            :first_name => credit_card_or_vault_id.first_name,
+            :last_name => credit_card_or_vault_id.last_name
+          )
+          parameters[:credit_card] = {
+            :number => credit_card_or_vault_id.number,
+            :cvv => credit_card_or_vault_id.verification_value,
+            :expiration_month => credit_card_or_vault_id.month.to_s.rjust(2, "0"),
+            :expiration_year => credit_card_or_vault_id.year.to_s
+          }
+        end
+        parameters[:billing] = map_address(options[:billing_address]) if options[:billing_address]
+        parameters[:shipping] = map_address(options[:shipping_address]) if options[:shipping_address]
+        commit do
+          result = Braintree::Transaction.send(transaction_type, parameters)
+          response_params, response_options, avs_result, cvv_result = {}, {}, {}, {}
+          if result.success?
+            response_params[:braintree_transaction] = result.transaction
+            response_params[:customer_vault_id] = result.transaction.customer_details.id
+            response_options[:authorization] = result.transaction.id
+          end
+          if result.transaction
+            avs_result = {
+              'code' => '', 'message' => '',
+              'street_match' => result.transaction.avs_street_address_response_code == 'M',
+              'postal_match' => result.transaction.avs_postal_code_response_code == 'M'
+            }
+            cvv_result = {
+              'code' => result.transaction.cvv_response_code, 'message' => ''
+            }
+            message = result.transaction.processor_response_code + " " + result.transaction.processor_response_text
+          else
+            message = message_from_result(result)
+          end
+          response = Response.new(result.success?, message, response_params, response_options)
+          response.instance_variable_set("@avs_result", avs_result)
+          response.instance_variable_set("@cvv_result", cvv_result)
+          response
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) +  '/smart_ps.rb'
+require File.dirname(__FILE__) + '/braintree/braintree_common'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BraintreeOrangeGateway < SmartPs
+      include BraintreeCommon
+
+      self.display_name = 'Braintree (Orange Platform)'
+      
+      def api_url
+        'https://secure.braintreepaymentgateway.com/api/transact.php'
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,230 @@
+module ActiveMerchant #: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[a[0].gsub(/^VP/,'').underscore.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
+