spree_core 1.3.2 → 1.3.3

data/app/models/spree/calculator/default_tax.rb

@@ -33,7 +33,11 @@ module Spree
 
       def compute_line_item(line_item)
         if line_item.product.tax_category == rate.tax_category
-          deduced_total_by_rate(line_item.total, rate)
+          if rate.included_in_price
+            deduced_total_by_rate(line_item.total, rate)
+          else
+            round_to_two_places(line_item.total * rate.amount)
+          end
         else
           0
         end

data/app/models/spree/calculator/per_item.rb

@@ -14,7 +14,7 @@ module Spree
     def compute(object=nil)
       return 0 if object.nil?
       self.preferred_amount * object.line_items.reduce(0) do |sum, value|
-        if !matching_products || matching_products.include?(value.product)
+        if matching_products.blank? || matching_products.include?(value.product)
           value_to_add = value.quantity
         else
           value_to_add = 0

data/app/models/spree/classification.rb

@@ -0,0 +1,7 @@
+module Spree
+  class Classification < ActiveRecord::Base
+    self.table_name = 'spree_products_taxons'
+    belongs_to :product, :class_name => "Spree::Product"
+    belongs_to :taxon, :class_name => "Spree::Taxon"
+  end
+end

data/app/models/spree/credit_card.rb

@@ -14,10 +14,6 @@ module Spree
     attr_accessible :first_name, :last_name, :number, :verification_value, :year,
                     :month, :gateway_customer_profile_id, :gateway_payment_profile_id
 
-    def number=(num)
-      @number = num.gsub(/[^0-9]/, '') rescue nil
-    end
-
     def set_last_digits
       number.to_s.gsub!(/\s/,'')
       verification_value.to_s.gsub!(/\s/,'')
@@ -64,7 +60,7 @@ module Spree
 
     # needed for some of the ActiveMerchant gateways (eg. SagePay)
     def brand
-      cc_type
+      spree_cc_type
     end
 
     scope :with_payment_profile, lambda { where('gateway_customer_profile_id IS NOT NULL') }

data/app/models/spree/gateway.rb

@@ -21,7 +21,9 @@ module Spree
     def provider
       gateway_options = options
       gateway_options.delete :login if gateway_options.has_key?(:login) and gateway_options[:login].nil?
-      ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
+      if gateway_options[:server]
+        ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
+      end
       @provider ||= provider_class.new(gateway_options)
     end
 
@@ -33,7 +35,7 @@ module Spree
       if @provider.nil? || !@provider.respond_to?(method)
         super
       else
-        provider.send(method)
+        provider.send(method, *args)
       end
     end
 
@@ -44,5 +46,11 @@ module Spree
     def method_type
       'gateway'
     end
+
+    def supports?(source)
+      return true unless provider_class.respond_to? :supports?
+      return false unless source.brand
+      provider_class.supports?(source.brand)
+    end
   end
 end

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

@@ -1,11 +1,11 @@
 module Spree
   class Gateway::Bogus < Gateway
-    TEST_VISA = '4111111111111111'
-    TEST_MC   = '5500000000000004'
-    TEST_AMEX = '340000000000009'
-    TEST_DISC = '6011000000000004'
+    TEST_VISA = ['4111111111111111','4012888888881881','4222222222222']
+    TEST_MC   = ['5500000000000004','5555555555554444','5105105105105100']
+    TEST_AMEX = ['378282246310005','371449635398431','378734493671000','340000000000009']
+    TEST_DISC = ['6011000000000004','6011111111111117','6011000990139424']
 
-    VALID_CCS = ['1', TEST_VISA, TEST_MC, TEST_AMEX, TEST_DISC]
+    VALID_CCS = ['1', TEST_VISA, TEST_MC, TEST_AMEX, TEST_DISC].flatten
 
     attr_accessor :test
 

data/app/models/spree/inventory_unit.rb

@@ -1,9 +1,9 @@
 module Spree
   class InventoryUnit < ActiveRecord::Base
-    belongs_to :variant
-    belongs_to :order
-    belongs_to :shipment
-    belongs_to :return_authorization
+    belongs_to :variant, :class_name => "Spree::Variant"
+    belongs_to :order, :class_name => "Spree::Order"
+    belongs_to :shipment, :class_name => "Spree::Shipment"
+    belongs_to :return_authorization, :class_name => "Spree::ReturnAuthorization"
 
     scope :backordered, lambda { where(:state => 'backordered') }
     scope :shipped, lambda { where(:state => 'shipped') }

data/app/models/spree/line_item.rb

@@ -1,7 +1,7 @@
 module Spree
   class LineItem < ActiveRecord::Base
     before_validation :adjust_quantity
-    belongs_to :order
+    belongs_to :order, :class_name => "Spree::Order"
     belongs_to :variant, :class_name => "Spree::Variant"
 
     has_one :product, :through => :variant

data/app/models/spree/order.rb

@@ -24,7 +24,7 @@ module Spree
         order.payment_required?
       }
       go_to_state :confirm, :if => lambda { |order| order.confirmation_required? }
-      go_to_state :complete, :if => lambda { |order| (order.payment_required? && order.payments.exists?) || !order.payment_required? }
+      go_to_state :complete, :if => lambda { |order| (order.payment_required? && order.has_unprocessed_payments?) || !order.payment_required? }
       remove_transition :from => :delivery, :to => :confirm
     end
 
@@ -164,7 +164,14 @@ module Spree
 
     # If true, causes the confirmation step to happen during the checkout process
     def confirmation_required?
-      payment_method && payment_method.payment_profiles_supported?
+      payments.map(&:payment_method).any?(&:payment_profiles_supported?)
+    end
+
+    # Used by the checkout state machine to check for unprocessed payments
+    # The Order should be unable to proceed to complete if there are unprocessed
+    # payments and there is payment required.
+    def has_unprocessed_payments?
+      payments.with_state('checkout').reload.exists?
     end
 
     # Indicates the number of items in the order
@@ -214,7 +221,7 @@ module Spree
     end
 
     def updater
-      OrderUpdater.new(self)
+      @updater ||= OrderUpdater.new(self)
     end
 
     def update!
@@ -375,11 +382,11 @@ module Spree
       adjustments.each { |adjustment| adjustment.update_column('locked', true) }
 
       # update payment and shipment(s) states, and save
-      updater = OrderUpdater.new(self)
       updater.update_payment_state
       shipments.each { |shipment| shipment.update!(self) }
       updater.update_shipment_state
       save
+      updater.run_hooks
 
       deliver_order_confirmation_email
 
@@ -393,7 +400,7 @@ module Spree
 
     def deliver_order_confirmation_email
       begin
-        OrderMailer.confirm_email(self).deliver
+        OrderMailer.confirm_email(self.id).deliver
       rescue Exception => e
         logger.error("#{e.class.name}: #{e.message}")
         logger.error(e.backtrace * "\n")
@@ -408,23 +415,8 @@ module Spree
     end
 
     def rate_hash
-      return @rate_hash if @rate_hash.present?
-
-      # reserve one slot for each shipping method computation
-      computed_costs = Array.new(available_shipping_methods(:front_end).size)
-
-      # create all the threads and kick off their execution
-      threads = available_shipping_methods(:front_end).each_with_index.map do |ship_method, index|
-        Thread.new { computed_costs[index] = [ship_method, ship_method.calculator.compute(self)] }
-      end      
-
-      # wait for all threads to finish
-      threads.map(&:join)
-
-      # now consolidate and memoize the threaded results
-      @rate_hash ||= computed_costs.map do |pair|
-        ship_method,cost = *pair
-        next unless cost
+      @rate_hash ||= available_shipping_methods.collect do |ship_method|
+        next unless cost = ship_method.calculator.compute(self)
         ShippingRate.new( :id => ship_method.id,
                           :shipping_method => ship_method,
                           :name => ship_method.name,
@@ -437,22 +429,10 @@ module Spree
       payment_state == 'paid'
     end
 
-    def payment
-      payments.first
-    end
-
     def available_payment_methods
       @available_payment_methods ||= PaymentMethod.available(:front_end)
     end
 
-    def payment_method
-      if payment and payment.payment_method
-        payment.payment_method
-      else
-        available_payment_methods.first
-      end
-    end
-
     def pending_payments
       payments.select {|p| p.state == "checkout"}
     end
@@ -565,7 +545,7 @@ module Spree
         restock_items!
 
         #TODO: make_shipments_pending
-        OrderMailer.cancel_email(self).deliver
+        OrderMailer.cancel_email(self.id).deliver
         unless %w(partial shipped).include?(shipment_state)
           self.payment_state = 'credit_owed'
         end

data/app/models/spree/order/checkout.rb

@@ -7,6 +7,7 @@ module Spree
           class_attribute :previous_states
           class_attribute :checkout_flow
           class_attribute :checkout_steps
+          class_attribute :removed_transitions
 
           def self.checkout_flow(&block)
             if block_given?
@@ -22,6 +23,7 @@ module Spree
             self.checkout_steps = ActiveSupport::OrderedHash.new
             self.next_event_transitions = []
             self.previous_states = [:cart]
+            self.removed_transitions = []
 
             # Build the checkout flow using the checkout_flow defined either
             # within the Order class, or a decorator for that class.
@@ -93,7 +95,40 @@ module Spree
             end
           end
 
+          def self.insert_checkout_step(name, options = {})
+            before = options.delete(:before)
+            after = options.delete(:after) unless before
+            after = self.checkout_steps.keys.last unless before || after
+
+            cloned_steps = self.checkout_steps.clone
+            cloned_removed_transitions = self.removed_transitions.clone
+            self.checkout_flow do
+              cloned_steps.each_pair do |key, value|
+                self.go_to_state(name, options) if key == before
+                self.go_to_state(key, value)
+                self.go_to_state(name, options) if key == after
+              end
+              cloned_removed_transitions.each do |transition|
+                self.remove_transition(transition)
+              end
+            end
+          end
+
+          def self.remove_checkout_step(name)
+            cloned_steps = self.checkout_steps.clone
+            cloned_removed_transitions = self.removed_transitions.clone
+            self.checkout_flow do
+              cloned_steps.each_pair do |key, value|
+                self.go_to_state(key, value) unless key == name
+              end
+              cloned_removed_transitions.each do |transition|
+                self.remove_transition(transition)
+              end
+            end
+          end
+
           def self.remove_transition(options={})
+            self.removed_transitions << options
             if transition = find_transition(options)
               self.next_event_transitions.delete(transition)
             end
@@ -131,6 +166,23 @@ module Spree
             steps << "complete" unless steps.include?("complete")
             steps
           end
+
+          def has_checkout_step?(step)
+            step.present? ? self.checkout_steps.include?(step) : false
+          end
+
+          def checkout_step_index(step)
+            self.checkout_steps.index(step)
+          end
+
+          def self.removed_transitions
+            @removed_transitions ||= []
+          end
+
+          def can_go_to_state?(state)
+            return false unless self.state.present? && has_checkout_step?(state) && has_checkout_step?(self.state)
+            checkout_step_index(state) > checkout_step_index(self.state)
+          end
         end
       end
     end

data/app/models/spree/order_populator.rb

@@ -38,6 +38,11 @@ module Spree
 
     def attempt_cart_add(variant_id, quantity)
       quantity = quantity.to_i
+      if quantity > Spree::Config[:max_quantity]
+        errors.add(:base, I18n.t(:please_enter_reasonable_quantity, :scope => :order_populator))
+        return false
+      end
+
       variant = Spree::Variant.find(variant_id)
       if quantity > 0
         if check_stock_levels(variant, quantity)
@@ -55,12 +60,15 @@ module Spree
         if on_hand >= quantity || Spree::Config[:allow_backorders]
           return true
         else
-          errors.add(:base, %Q{There are only #{on_hand} of #{display_name.inspect} remaining.} + 
-                            %Q{ Please select a quantity less than or equal to this value.})
+          remainder_message = I18n.t(:remainder_message,
+                                     :item => display_name.inspect,
+                                     :on_hand => on_hand,
+                                     :scope => :order_populator)
+          errors.add(:base, remainder_message)
           return false
         end
       else
-        errors.add(:base, %Q{#{display_name.inspect} is out of stock.})
+        errors.add(:base, I18n.t(:out_of_stock, :item => display_name.inspect, :scope => :order_populator))
         return false
       end
     end

data/app/models/spree/order_updater.rb

@@ -34,11 +34,10 @@ module Spree
         :total => order.total
       })
 
-      #ensure checkout payment always matches order total
-      if order.payment and order.payment.checkout? and order.payment.amount != order.total
-        order.payment.update_attributes_without_callbacks(:amount => order.total)
-      end
+      run_hooks
+    end
 
+    def run_hooks
       update_hooks.each { |hook| order.send hook }
     end
 

data/app/models/spree/payment.rb

@@ -14,6 +14,8 @@ module Spree
 
     # update the order totals, etc.
     after_save :update_order
+    # invalidate previously entered payments
+    after_create :invalidate_old_payments
 
     attr_accessor :source_attributes
     after_initialize :build_source
@@ -25,6 +27,15 @@ module Spree
     scope :completed, with_state('completed')
     scope :pending, with_state('pending')
     scope :failed, with_state('failed')
+    scope :valid, where("state NOT IN (?)", %w(failed invalid))
+
+    after_rollback :persist_invalid
+
+    def persist_invalid
+      return unless ['failed', 'invalid'].include?(state)
+      state_will_change!
+      save 
+    end
 
     # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
     state_machine :initial => 'checkout' do
@@ -47,15 +58,20 @@ module Spree
       event :void do
         transition :from => ['pending', 'completed', 'checkout'], :to => 'void'
       end
+      # when the card brand isnt supported
+      event :invalidate do
+        transition :from => ['checkout'], :to => 'invalid'
+      end
     end
 
     def currency
       order.currency
     end
 
-    def display_amount
+    def money
       Spree::Money.new(amount, { :currency => currency })
     end
+    alias display_amount money
 
     def offsets_total
       offsets.pluck(:amount).sum
@@ -106,6 +122,12 @@ module Spree
         gateway_error e
       end
 
+      def invalidate_old_payments
+        order.payments.with_state('checkout').where("id != ?", self.id).each do |payment|
+          payment.invalidate!
+        end
+      end
+
       def update_order
         order.payments.reload
         order.update!

data/app/models/spree/payment/processing.rb

@@ -5,10 +5,15 @@ module Spree
         if payment_method && payment_method.source_required?
           if source
             if !processing?
-              if payment_method.auto_capture?
-                purchase!
+              if payment_method.supports?(source)
+                if payment_method.auto_capture?
+                  purchase!
+                else
+                  authorize!
+                end
               else
-                authorize!
+                invalidate!
+                raise Core::GatewayError.new(I18n.t(:payment_method_not_supported))
               end
             end
           else
@@ -39,7 +44,7 @@ module Spree
             response = payment_method.capture(self, source, gateway_options)
           else
             # Standard ActiveMerchant capture usage
-            response = payment_method.capture((amount * 100).round,
+            response = payment_method.capture(money.money.cents,
                                               response_code,
                                               gateway_options)
           end
@@ -111,7 +116,11 @@ module Spree
       options = { :email    => order.email,
                   :customer => order.email,
                   :ip       => order.last_ip_address,
-                  :order_id => "#{order.number}-#{self.identifier}" }
+                  # Need to pass in a unique identifier here to make some
+                  # payment gateways happy.
+                  #
+                  # For more information, please see Spree::Payment#set_unique_identifier
+                  :order_id => gateway_order_id }
 
       options.merge!({ :shipping => order.ship_total * 100,
                        :tax      => order.tax_total * 100,
@@ -187,5 +196,9 @@ module Spree
       raise Core::GatewayError.new(message)
     end
 
+    # The unique identifier to be passed in to the payment gateway
+    def gateway_order_id
+      "#{order.number}-#{self.identifier}"
+    end
   end
 end