spree_gateway 2.1.1 → 2.2.0

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

@@ -1,65 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,193 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

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

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

@@ -1,20 +0,0 @@
-module Spree
-  class Gateway::Eway < Gateway
-    preference :login, :string
-
-    # Note: EWay supports purchase method only (no authorize method).
-    def auto_capture?
-      true
-    end
-
-    def provider_class
-      ActiveMerchant::Billing::EwayGateway
-    end
-
-    def options_with_test_preference
-      options_without_test_preference.merge(:test => self.preferred_test_mode)
-    end
-
-    alias_method_chain :options, :test_preference
-  end
-end