spree_core 0.40.4 → 0.50.0

data/app/models/app_configuration.rb

@@ -2,8 +2,6 @@ class AppConfiguration < Configuration
 
   preference :site_name, :string, :default => 'Spree Demo Site'
   preference :site_url, :string, :default => 'demo.spreecommerce.com'
-  preference :store_cc, :boolean, :default => false
-  preference :store_cvv, :boolean, :default => false
   preference :default_locale, :string, :default => 'en'
   preference :allow_locale_switching, :boolean, :default => true
   preference :default_country_id, :integer, :default => 214
@@ -23,7 +21,6 @@ class AppConfiguration < Configuration
   preference :allow_ssl_in_production, :boolean, :default => true
   preference :allow_ssl_in_development_and_test, :boolean, :default => false
   preference :allow_guest_checkout, :boolean, :default => true
-  preference :allow_anonymous_checkout, :boolean, :default => false
   preference :alternative_billing_phone,  :boolean, :default => false # Request extra phone for bill addr
   preference :alternative_shipping_phone, :boolean, :default => false # Request extra phone for ship addr
   preference :shipping_instructions,      :boolean, :default => false # Request instructions/info for shipping
@@ -35,9 +32,6 @@ class AppConfiguration < Configuration
   preference :cache_static_content, :boolean, :default => true
   preference :use_content_controller, :boolean, :default => true
   preference :allow_checkout_on_gateway_error, :boolean, :default => false
-  preference :check_for_spree_alerts, :boolean, :default => true
-  preference :dismissed_spree_alerts, :string, :default => ''
-  preference :last_check_for_spree_alerts, :string, :default => nil
 
   validates :name, :presence => true, :uniqueness => true
 

data/app/models/billing_integration.rb

@@ -7,7 +7,7 @@ class BillingIntegration < PaymentMethod
 
   def provider
     integration_options = options
-    ActiveMerchant::Billing::Base.integration_mode = integration_options[:server]
+    ActiveMerchant::Billing::Base.integration_mode = integration_options[:server].to_sym
     integration_options = options
     integration_options[:test] = true if integration_options[:test_mode]
     @provider ||= provider_class.new(integration_options)

data/app/models/calculator/sales_tax.rb

@@ -3,12 +3,12 @@ class Calculator::SalesTax < Calculator
   def self.description
     I18n.t("sales_tax")
   end
-    
+
   def self.register
     super
     TaxRate.register_calculator(self)
   end
-  
+
   def self.calculate_tax(order, rates)
     ActiveSupport::Deprecation.warn("please use Calculator::SalesTax#compute instead", caller)
 
@@ -16,7 +16,7 @@ class Calculator::SalesTax < Calculator
     # note: there is a bug with associations in rails 2.1 model caching so we're using this hack
     # (see http://rails.lighthouseapp.com/projects/8994/tickets/785-caching-models-fails-in-development)
     cache_hack = rates.first.respond_to?(:tax_category_id)
-            
+
     taxable_totals = {}
     order.line_items.each do |line_item|
       next unless tax_category = line_item.variant.product.tax_category

data/app/models/configuration.rb

@@ -1,3 +1,3 @@
 class Configuration < ActiveRecord::Base
-  
+
 end

data/app/models/country.rb

@@ -1,12 +1,11 @@
 class Country < ActiveRecord::Base
   has_many :states
-  
-  has_one     :zone_member, :as => :zoneable
-  has_one     :zone,        :through => :zone_member
 
-  scope :order_by_name, :order => :name  
+  has_one :zone_member, :as => :zoneable
+  has_one :zone, :through => :zone_member
+
   validates :name, :iso_name, :presence => true
-  
+
   def <=>(other)
     name <=> other.name
   end

data/app/models/creditcard.rb

@@ -10,12 +10,10 @@ class Creditcard < ActiveRecord::Base
   validates :verification_value, :presence => true, :unless => :has_payment_profile?, :on => :create
 
   def process!(payment)
-    begin
-      if Spree::Config[:auto_capture]
-        purchase(payment.amount.to_f, payment)
-      else
-        authorize(payment.amount.to_f, payment)
-      end
+    if Spree::Config[:auto_capture]
+      purchase(payment.amount.to_f, payment)
+    else
+      authorize(payment.amount.to_f, payment)
     end
   end
 
@@ -30,19 +28,19 @@ class Creditcard < ActiveRecord::Base
   end
 
   def first_name?
-    !self.first_name.blank?
+    first_name.present?
   end
 
   def last_name?
-    !self.last_name.blank?
+    last_name.present?
   end
 
   def name
-    "#{self.first_name} #{self.last_name}"
+    "#{first_name} #{last_name}"
   end
 
   def verification_value?
-    !verification_value.blank?
+    verification_value.present?
   end
 
   # Show the card number, with all but last 4 numbers replace with "X". (XXXX-XXXX-XXXX-4338)
@@ -63,6 +61,9 @@ class Creditcard < ActiveRecord::Base
 
   def authorize(amount, payment)
     # ActiveMerchant is configured to use cents so we need to multiply order total by 100
+    payment_gateway = payment.payment_method
+    check_environment(payment_gateway)
+
     response = payment_gateway.authorize((amount * 100).round, self, gateway_options(payment))
     record_log payment, response
 
@@ -74,12 +75,15 @@ class Creditcard < ActiveRecord::Base
       payment.fail
       gateway_error(response)
     end
-  rescue ActiveMerchant::ConnectionError => e
+  rescue ActiveMerchant::ConnectionError
     gateway_error I18n.t(:unable_to_connect_to_gateway)
   end
 
   def purchase(amount, payment)
     #combined Authorize and Capture that gets processed by the ActiveMerchant gateway as one single transaction.
+    payment_gateway = payment.payment_method
+    check_environment(payment_gateway)
+
     response = payment_gateway.purchase((amount * 100).round, self, gateway_options(payment))
     record_log payment, response
 
@@ -91,12 +95,15 @@ class Creditcard < ActiveRecord::Base
       payment.fail
       gateway_error(response) unless response.success?
     end
-  rescue ActiveMerchant::ConnectionError => e
+  rescue ActiveMerchant::ConnectionError
     gateway_error t(:unable_to_connect_to_gateway)
   end
 
   def capture(payment)
     return unless payment.pending?
+    payment_gateway = payment.payment_method
+    check_environment(payment_gateway)
+
     if payment_gateway.payment_profiles_supported?
       # Gateways supporting payment profiles will need access to creditcard object because this stores the payment profile information
       # so supply the authorization itself as well as the creditcard, rather than just the authorization code
@@ -115,11 +122,14 @@ class Creditcard < ActiveRecord::Base
       payment.fail
       gateway_error(response)
     end
-  rescue ActiveMerchant::ConnectionError => e
+  rescue ActiveMerchant::ConnectionError
     gateway_error I18n.t(:unable_to_connect_to_gateway)
   end
 
   def void(payment)
+    payment_gateway = payment.payment_method
+    check_environment(payment_gateway)
+
     response = payment_gateway.void(payment.response_code, minimal_gateway_options(payment))
     record_log payment, response
 
@@ -129,11 +139,14 @@ class Creditcard < ActiveRecord::Base
     else
       gateway_error(response)
     end
-  rescue ActiveMerchant::ConnectionError => e
+  rescue ActiveMerchant::ConnectionError
     gateway_error I18n.t(:unable_to_connect_to_gateway)
   end
 
   def credit(payment)
+    payment_gateway = payment.payment_method
+    check_environment(payment_gateway)
+
     amount = payment.credit_allowed >= payment.order.outstanding_balance.abs ? payment.order.outstanding_balance.abs : payment.credit_allowed.abs
 
     if payment_gateway.payment_profiles_supported?
@@ -154,13 +167,10 @@ class Creditcard < ActiveRecord::Base
     else
       gateway_error(response)
     end
-  rescue ActiveMerchant::ConnectionError => e
+  rescue ActiveMerchant::ConnectionError
     gateway_error I18n.t(:unable_to_connect_to_gateway)
   end
 
-
-
-
   def actions
     %w{capture void credit}
   end
@@ -170,20 +180,14 @@ class Creditcard < ActiveRecord::Base
     payment.state == "pending"
   end
 
-  # Indicates whether its possible to void the payment.  Most gateways require that the payment has not been
-  # settled yet when performing a void (which generally happens within 12-24 hours of the transaction.)  For
-  # this reason, the default behavior of Spree is to only allow void operations within the first 12 hours of
-  # the payment creation time.
+  # Indicates whether its possible to void the payment.
   def can_void?(payment)
-    return false unless (Time.now - 12.hours) < payment.created_at
-    %w{completed pending}.include? payment.state
+    payment.state == "void" ? false : true
   end
 
-  # Indicates whether its possible to credit the payment.  Most gateways require that the payment be settled
-  # first which generally happens within 12-24 hours of the transaction.  For this reason, the default
-  # behavior of Spree is to disallow credit operations until the payment is at least 12 hours old.
+  # Indicates whether its possible to credit the payment.  Note that most gateways require that the
+  # payment be settled first which generally happens within 12-24 hours of the transaction.
   def can_credit?(payment)
-    return false unless (Time.now - 12.hours) > payment.created_at
     return false unless payment.state == "completed"
     return false unless payment.order.payment_state == "credit_owed"
     payment.credit_allowed > 0
@@ -239,8 +243,11 @@ class Creditcard < ActiveRecord::Base
     self.class.type?(number)
   end
 
-  def payment_gateway
-    @payment_gateway ||= Gateway.current
+  # Saftey check to make sure we're not accidentally performing operations on a live gateway.
+  # Ex. When testing in staging environment with a copy of production data.
+  def check_environment(gateway)
+    return if gateway.environment == Rails.env
+    message = I18n.t(:gateway_config_unavailable) + " - #{Rails.env}"
+    raise Spree::GatewayError.new(message)
   end
-
 end

data/app/models/gateway.rb

@@ -1,48 +1,48 @@
 class Gateway < PaymentMethod
 	delegate_belongs_to :provider, :authorize, :purchase, :capture, :void, :credit
-	
+
 	validates :name, :type, :presence => true
-  
+
   preference :server, :string, :default => 'test'
   preference :test_mode, :boolean, :default => true
 
   def payment_source_class
     Creditcard
   end
-  
+
   # instantiates the selected gateway and configures with the options stored in the database
   def self.current
     super
-	end	
-  
+	end
+
   def provider
     gateway_options = options
     ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
     @provider ||= provider_class.new(gateway_options)
-  end 
- 
+  end
+
 	def options
     options_hash = {}
-    self.preferences.each do |key,value| 
+    self.preferences.each do |key,value|
       options_hash[key.to_sym] = value
     end
     options_hash
 	end
-	
+
 	def method_missing(method, *args)
-	 	if @provider.nil?
+	 	if @provider.nil? || !@provider.respond_to?(method)
 			super
 		else
-			@provider.respond_to?(method) ? provider.send(method) : super
+      provider.send(method)
 		end
 	end
-	
+
 	def payment_profiles_supported?
 	  false
   end
-  
+
   def method_type
     "gateway"
   end
-  
+
 end

data/app/models/gateway/beanstream.rb

@@ -26,11 +26,11 @@ class Gateway::Beanstream < Gateway
       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
@@ -41,13 +41,13 @@ class Gateway::Beanstream < Gateway
   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?

data/app/models/gateway/bogus.rb

@@ -15,7 +15,7 @@ class Gateway::Bogus < Gateway
   def preferences
     {}
   end
-  
+
   def create_profile(payment)
     # simulate the storage of credit card profile using remote service
     success = VALID_CCS.include? payment.source.number
@@ -24,7 +24,7 @@ class Gateway::Bogus < Gateway
 
   def authorize(money, creditcard, options = {})
     profile_id = creditcard.gateway_customer_profile_id
-    if VALID_CCS.include? creditcard.number or (profile_id and profile_id.starts_with? "BGS-") 
+    if VALID_CCS.include? creditcard.number or (profile_id and profile_id.starts_with? "BGS-")
       ActiveMerchant::Billing::Response.new(true, "Bogus Gateway: Forced success", {}, :test => true, :authorization => '12345', :avs_result => {:code => 'A'})
     else
       ActiveMerchant::Billing::Response.new(false, "Bogus Gateway: Forced failure", {:message => 'Bogus Gateway: Forced failure'}, :test => true)
@@ -61,11 +61,11 @@ class Gateway::Bogus < Gateway
     # Test mode is not really relevant with bogus gateway (no such thing as live server)
     true
   end
-  
-  def payment_profiles_supported?  
+
+  def payment_profiles_supported?
     true
   end
-  
+
   private
   def generate_profile_id(success)
     record = true
@@ -75,6 +75,6 @@ class Gateway::Bogus < Gateway
       record = Creditcard.find(:first, :conditions => ["gateway_customer_profile_id = ?", random])
     end
     random
-  end  
+  end
 
 end

data/app/models/gateway/braintree.rb

@@ -0,0 +1,88 @@
+class Gateway::Braintree < Gateway
+	preference :merchant_id, :string
+	preference :public_key, :string
+	preference :private_key, :string
+
+  def provider_class
+    ActiveMerchant::Billing::BraintreeGateway
+  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"])
+      else
+        payment.source.gateway_error response.message
+      end
+    end
+  end
+
+  def credit(*args)
+    if args.size == 4
+      credit_with_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
+
+  def credit_with_payment_profiles(amount, payment, response_code, option)
+    provider.credit(amount, payment)
+  end
+
+  def credit_without_payment_profiles(amount, response_code, options)
+    transaction = ::Braintree::Transaction.find(response_code)
+    if BigDecimal.new(amount.to_s) == (transaction.amount * 100)
+      provider.refund(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
+
+  protected
+
+  def adjust_country_name(options)
+    [:billing_address, :shipping_address].each do |address|
+      if options[address] && options[address][:country] == "US"
+        options[address][:country] = "United States of America"
+      end
+    end
+  end
+
+  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_country_name(options)
+    adjust_billing_address(creditcard, options)
+  end
+end
+