spree_gateway 2.1.0 → 2.1.1

data/app/models/spree/gateway/balanced_gateway.rb

@@ -0,0 +1,65 @@
+module Spree
+  class Gateway::BalancedGateway < Gateway
+    preference :login, :string
+    preference :on_behalf_of_uri, :string
+
+    def authorize(money, creditcard, gateway_options)
+      if token = creditcard.gateway_payment_profile_id
+        # The Balanced ActiveMerchant gateway supports passing the token directly as the creditcard parameter
+        creditcard = token
+      end
+      provider.authorize(money, creditcard, gateway_options)
+    end
+
+    def capture(authorization, creditcard, gateway_options)
+      gateway_options[:on_behalf_of_uri] = self.preferred_on_behalf_of_uri
+      provider.capture((authorization.amount * 100).round, authorization.response_code, gateway_options)
+    end
+
+    def create_profile(payment)
+      return unless payment.source.gateway_payment_profile_id.nil?
+
+      options = {}
+      options[:email] = payment.order.email
+      options[:login] = preferred_login
+
+      card_store_response = provider.store(payment.source, options)
+      card_uri = card_store_response.authorization.split(';').first
+      
+      # A success just returns a string of the token. A failed request returns a bad request response with a message.
+      payment.source.update_attributes!(:gateway_payment_profile_id => card_uri)
+    rescue Error => ex
+      payment.send(:gateway_error, ex.message)
+    end
+
+    def options_with_test_preference
+      options_without_test_preference.merge(:test => self.preferred_test_mode)
+    end
+    alias_method_chain :options, :test_preference
+
+    def payment_profiles_supported?
+      true
+    end
+
+    def purchase(money, creditcard, gateway_options)
+      if token = creditcard.gateway_payment_profile_id
+        # The Balanced ActiveMerchant gateway supports passing the token directly as the creditcard parameter
+        creditcard = token
+      end
+      provider.purchase(money, creditcard, gateway_options)
+    end
+
+    def provider_class
+      ActiveMerchant::Billing::BalancedGateway
+    end
+
+    def credit(money, creditcard, response_code, gateway_options)
+      provider.refund(money, response_code, {})
+    end
+
+    def void(response_code, creditcard, gateway_options)
+      provider.void(response_code)
+    end
+
+  end
+end

data/app/models/spree/gateway/banwire.rb

@@ -0,0 +1,15 @@
+module Spree
+  class Gateway::Banwire < Gateway
+    preference :login, :string
+
+
+    def provider_class
+      ActiveMerchant::Billing::BanwireGateway
+    end
+
+    def purchase(money, creditcard, gateway_options)
+      gateway_options[:description] = "Spree Order"
+      provider.purchase(money, creditcard, gateway_options)
+    end
+  end
+end

data/app/models/spree/gateway/beanstream.rb

@@ -0,0 +1,193 @@
+module Spree
+  class Gateway::Beanstream < Gateway
+    preference :login, :string
+    preference :user, :string
+    preference :password, :string
+    preference :secure_profile_api_key, :string
+
+    def provider_class
+      ActiveMerchant::Billing::BeanstreamGateway
+    end
+
+    def payment_profiles_supported?
+      true
+    end
+
+    def create_profile(payment)
+      creditcard = payment.source
+      if creditcard.gateway_customer_profile_id.nil?
+        options = options_for_create_customer_profile(creditcard, {})
+        verify_creditcard_name!(creditcard)
+        result = provider.store(creditcard, options)
+        if result.success?
+          creditcard.update_attributes(:gateway_customer_profile_id => result.params['customerCode'], :gateway_payment_profile_id => result.params['customer_vault_id'])
+        else
+          payment.send(:gateway_error, result)
+        end
+      end
+    end
+
+    def capture(transaction, creditcard, gateway_options)
+      beanstream_gateway.capture((transaction.amount*100).round, transaction.response_code, gateway_options)
+    end
+
+    def void(transaction_response, creditcard, gateway_options)
+      beanstream_gateway.void(transaction_response, gateway_options)
+    end
+
+    def credit(amount, creditcard, response_code, gateway_options = {})
+      amount = (amount * -1) if amount < 0
+      beanstream_gateway.credit(amount, response_code, gateway_options)
+    end
+
+    private
+      def beanstream_gateway
+        ActiveMerchant::Billing::Base.gateway_mode = preferred_server.to_sym
+        gateway_options = options
+        ActiveMerchant::Billing::BeanstreamGateway.new(gateway_options)
+      end
+
+      def verify_creditcard_name!(creditcard)
+        bill_address = creditcard.payments.first.order.bill_address
+        creditcard.first_name = bill_address.firstname unless creditcard.first_name?
+        creditcard.last_name = bill_address.lastname   unless creditcard.last_name?
+      end
+
+      def options_for_create_customer_profile(creditcard, gateway_options)
+        order = creditcard.payments.first.order
+        address = order.bill_address
+        { :email=>order.email,
+          :billing_address=>
+          { :name=>address.full_name,
+            :phone=>address.phone,
+            :address1=>address.address1,
+            :address2=>address.address2,
+            :city=>address.city,
+            :state=>address.state_name || address.state.abbr,
+            :country=>address.country.iso,
+            :zip=>address.zipcode
+            }
+          }.merge(gateway_options)
+      end
+
+      SECURE_PROFILE_URL = 'https://www.beanstream.com/scripts/payment_profile.asp'
+      SP_SERVICE_VERSION = '1.1'
+      PROFILE_OPERATIONS = { :new => 'N', :modify => 'M' }
+
+      ActiveMerchant::Billing::BeanstreamGateway.class_eval do
+
+        def store(credit_card, options = {})
+          post = {}
+          add_address(post, options)
+          add_credit_card(post, credit_card)
+          add_secure_profile_variables(post,options)
+          commit(post, true)
+        end
+
+        #can't actually delete a secure profile with the supplicaed API. This function sets the status of the profile to closed (C).
+        #Closed profiles will have to removed manually.
+        def delete(vault_id)
+          update(vault_id, false, { :status => 'C' })
+        end
+
+        #alias_method :unstore, :delete
+
+        # 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, credit_card, options = {})
+          post = {}
+          add_address(post, options)
+          add_credit_card(post, credit_card)
+          options.merge!({ :vault_id => vault_id, :operation => secure_profile_action(:modify) })
+          add_secure_profile_variables(post,options)
+          commit(post, true)
+        end
+
+        # CORE #
+
+        def secure_profile_action(type)
+          PROFILE_OPERATIONS[type] || PROFILE_OPERATIONS[:new]
+        end
+
+        def add_credit_card(post, credit_card)
+          if credit_card
+            if credit_card.has_payment_profile?
+              post[:customerCode] = credit_card.gateway_customer_profile_id
+            else
+              post[:trnCardOwner] = credit_card.name
+              post[:trnCardNumber] = credit_card.number
+              post[:trnExpMonth] = format(credit_card.month, :two_digits)
+              post[:trnExpYear] = format(credit_card.year, :two_digits)
+              post[:trnCardCvd] = credit_card.verification_value
+            end
+          end
+        end
+
+        def add_secure_profile_variables(post, options = {})
+          post[:serviceVersion] = SP_SERVICE_VERSION
+          post[:responseFormat] = 'QS'
+          post[:cardValidation] = (options[:cardValidation].to_i == 1) || '0'
+
+          post[:operationType] = options[:operationType] || options[:operation] || secure_profile_action(:new)
+          post[:customerCode] = options[:billing_id] || options[:vault_id] || false
+          post[:status] = options[:status]
+        end
+
+        def commit(params, use_profile_api = false)
+          post(post_data(params,use_profile_api),use_profile_api)
+        end
+
+        def post(data, use_profile_api)
+          response = parse(ssl_post((use_profile_api ? SECURE_PROFILE_URL : ActiveMerchant::Billing::BeanstreamGateway::URL), data))
+          if response[:responseCode].eql?("17") # Found matching card
+            response[:responseCode] = "1"
+            response[:customerCode] = response[:matchedCustomerCode]
+          end
+          response[:customer_vault_id] = response[:customerCode] if response[:customerCode]
+          build_response(success?(response), message_from(response), response,
+                         :test => test? || response[:authCode] == 'TEST',
+                         :authorization => authorization_from(response),
+                         :cvv_result => ActiveMerchant::Billing::BeanstreamGateway::CVD_CODES[response[:cvdId]],
+                         :avs_result => { :code => (ActiveMerchant::Billing::BeanstreamGateway::AVS_CODES.include? response[:avsId]) ? ActiveMerchant::Billing::BeanstreamGateway::AVS_CODES[response[:avsId]] : response[:avsId] }
+                         )
+        end
+
+        def message_from(response)
+          response[:messageText] || response[:responseMessage]
+        end
+
+        def success?(response)
+          response[:responseType] == 'R' || response[:trnApproved] == '1' || response[:responseCode] == '1'
+        end
+
+        def add_source(post, source)
+          if source.is_a?(String) or source.is_a?(Integer)
+            post[:customerCode] = source
+          else
+            if source.respond_to?(:type) && source.type.to_s == 'check'
+              add_check(post, source)
+            else
+              add_credit_card(post, source)
+            end
+          end
+        end
+
+        def post_data(params, use_profile_api)
+          params[:requestType] = 'BACKEND'
+          if use_profile_api
+            params[:merchantId] = @options[:login]
+            params[:passCode] = @options[:secure_profile_api_key]
+          else
+            params[:username] = @options[:user] if @options[:user]
+            params[:password] = @options[:password] if @options[:password]
+            params[:merchant_id] = @options[:login]
+          end
+          params[:vbvEnabled] = '0'
+          params[:scEnabled] = '0'
+
+          params.reject { |k, v| v.blank? }.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+        end
+      end
+  end
+end

data/app/models/spree/gateway/braintree_gateway.rb

@@ -0,0 +1,147 @@
+module Spree
+  class Gateway::BraintreeGateway < Gateway
+    preference :environment, :string
+    preference :merchant_id, :string
+    preference :merchant_account_id, :string
+    preference :public_key, :string
+    preference :private_key, :string
+    preference :client_side_encryption_key, :text
+
+    CARD_TYPE_MAPPING = {
+      'American Express' => 'american_express',
+      'Diners Club' => 'diners_club',
+      'Discover' => 'discover',
+      'JCB' => 'jcb',
+      'Laser' => 'laser',
+      'Maestro' => 'maestro',
+      'MasterCard' => 'master',
+      'Solo' => 'solo',
+      'Switch' => 'switch',
+      'Visa' => 'visa'
+    }
+
+    def provider
+      provider_instance = super
+      Braintree::Configuration.custom_user_agent = "Spree #{Spree.version}"
+      Braintree::Configuration.environment = preferred_environment.to_sym
+      Braintree::Configuration.merchant_id = preferred_merchant_id
+      Braintree::Configuration.public_key = preferred_public_key
+      Braintree::Configuration.private_key = preferred_private_key
+
+      provider_instance
+    end
+
+    def provider_class
+      ActiveMerchant::Billing::BraintreeBlueGateway
+    end
+
+    def authorize(money, creditcard, options = {})
+      adjust_options_for_braintree(creditcard, options)
+      payment_method = creditcard.gateway_customer_profile_id || creditcard
+      provider.authorize(money, payment_method, options)
+    end
+
+    def capture(authorization, ignored_creditcard, ignored_options)
+      amount = (authorization.amount * 100).to_i
+      provider.capture(amount, authorization.response_code)
+    end
+
+    def create_profile(payment)
+      if payment.source.gateway_customer_profile_id.nil?
+        response = provider.store(payment.source)
+        if response.success?
+          payment.source.update_attributes!(:gateway_customer_profile_id => response.params['customer_vault_id'])
+          cc = response.params['braintree_customer'].fetch('credit_cards',[]).first
+          update_card_number(payment.source, cc) if cc
+        else
+          payment.send(:gateway_error, response.message)
+        end
+      end
+    end
+
+    def update_card_number(source, cc)
+      last_4 = cc['last_4']
+      source.last_digits = last_4 if last_4
+      source.gateway_payment_profile_id = cc['token']
+      source.cc_type = CARD_TYPE_MAPPING[cc['card_type']] if cc['card_type']
+      source.save!
+    end
+
+    def credit(*args)
+      if args.size == 4
+        # enables ability to refund instead of credit
+        args.slice!(1,1)
+        credit_without_payment_profiles(*args)
+      elsif args.size == 3
+        credit_without_payment_profiles(*args)
+      else
+        raise ArgumentError, "Expected 3 or 4 arguments, received #{args.size}"
+      end
+    end
+
+    # Braintree now disables credits by default, see https://www.braintreepayments.com/docs/ruby/transactions/credit
+    def credit_with_payment_profiles(amount, payment, response_code, option)
+      provider.credit(amount, payment)
+    end
+
+    def credit_without_payment_profiles(amount, response_code, options)
+      provider # braintree provider needs to be called here to properly configure braintree gem.
+      transaction = ::Braintree::Transaction.find(response_code)
+      if BigDecimal.new(amount.to_s) == (transaction.amount * 100)
+        provider.refund(response_code)
+      elsif BigDecimal.new(amount.to_s) < (transaction.amount * 100) # support partial refunds
+        provider.refund(amount, response_code)
+      else
+        raise NotImplementedError
+      end
+    end
+
+    def payment_profiles_supported?
+      true
+    end
+
+    def purchase(money, creditcard, options = {})
+      authorize(money, creditcard, options.merge(:submit_for_settlement => true))
+    end
+
+    def void(response_code, *ignored_options)
+      provider.void(response_code)
+    end
+
+    def options
+      h = super
+      # We need to add merchant_account_id only if present when creating BraintreeBlueGateway
+      # Remove it since it is always part of the preferences hash.
+      if h[:merchant_account_id].blank?
+        h.delete(:merchant_account_id) 
+      end 
+      h
+    end
+
+    def preferences
+      preferences = super.slice(:merchant_id,
+                                :merchant_account_id,
+                                :public_key,
+                                :private_key,
+                                :client_side_encryption_key,
+                                :environment)
+
+      # Must be either :production or :sandbox, not their string equivalents.
+      # Thanks to the Braintree gem.
+      preferences[:environment] = preferences[:environment].try(:to_sym) || :sandbox
+      preferences
+    end
+
+    protected
+
+      def adjust_billing_address(creditcard, options)
+        if creditcard.gateway_customer_profile_id
+          options.delete(:billing_address)
+        end
+      end
+
+      def adjust_options_for_braintree(creditcard, options)
+        adjust_billing_address(creditcard, options)
+      end
+  end
+end

data/app/models/spree/gateway/card_save.rb

@@ -0,0 +1,10 @@
+module Spree
+  class Gateway::CardSave < Gateway
+    preference :login, :string
+    preference :password, :string
+
+    def provider_class
+      ActiveMerchant::Billing::CardSaveGateway
+    end
+  end
+end

data/app/models/spree/gateway/data_cash.rb

@@ -0,0 +1,10 @@
+module Spree
+  class Gateway::DataCash < Gateway
+    preference :login, :string
+    preference :password, :string
+
+    def provider_class
+      ActiveMerchant::Billing::DataCashGateway
+    end
+  end
+end