spree_core 1.1.6 → 1.2.0.rc1

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

@@ -0,0 +1,124 @@
+module Spree
+  class Order < ActiveRecord::Base
+    module Checkout
+      def self.included(klass)
+        klass.class_eval do
+          cattr_accessor :next_event_transitions
+          cattr_accessor :previous_states
+          cattr_accessor :checkout_flow
+          cattr_accessor :checkout_steps
+
+          def self.checkout_flow(&block)
+            if block_given?
+              @checkout_flow = block
+            else
+              @checkout_flow
+            end
+          end
+
+          def self.define_state_machine!
+            self.checkout_steps = []
+            self.next_event_transitions = []
+            self.previous_states = [:cart]
+            instance_eval(&checkout_flow)
+            klass = self
+
+            state_machine :state, :initial => :cart do
+              klass.next_event_transitions.each { |t| transition(t.merge(:on => :next)) }
+
+              # Persist the state on the order
+              after_transition do |order|
+                order.state = order.state
+                order.save
+              end
+
+              event :cancel do
+                transition :to => :canceled, :if => :allow_cancel?
+              end
+
+              event :return do
+                transition :to => :returned, :from => :awaiting_return
+              end
+
+              event :resume do
+                transition :to => :resumed, :from => :canceled, :if => :allow_resume?
+              end
+
+              event :authorize_return do
+                transition :to => :awaiting_return
+              end
+
+              before_transition :to => :complete do |order|
+                begin
+                  order.process_payments!
+                rescue Spree::Core::GatewayError
+                  !!Spree::Config[:allow_checkout_on_gateway_error]
+                end
+              end
+
+              before_transition :to => :delivery, :do => :remove_invalid_shipments!
+
+              after_transition :to => :complete, :do => :finalize!
+              after_transition :to => :delivery, :do => :create_tax_charge!
+              after_transition :to => :resumed,  :do => :after_resume
+              after_transition :to => :canceled, :do => :after_cancel
+
+              after_transition :from => :delivery,  :do => :create_shipment!
+            end
+          end
+
+          def self.go_to_state(name, options={})
+            self.checkout_steps[name] = options
+            if options[:if]
+              previous_states.each do |state|
+                add_transition({:from => state, :to => name}.merge(options))
+              end
+              self.previous_states << name
+            else
+              previous_states.each do |state|
+                add_transition({:from => state, :to => name}.merge(options))
+              end
+              self.previous_states = [name]
+            end
+          end
+
+          def self.remove_transition(options={})
+            if transition = find_transition(options)
+              self.next_event_transitions.delete(transition)
+            end
+          end
+
+          def self.find_transition(options={})
+            self.next_event_transitions.detect do |transition|
+              transition[options[:from].to_sym] == options[:to].to_sym
+            end
+          end
+
+          def self.next_event_transitions
+            @next_event_transitions ||= []
+          end
+
+          def self.checkout_steps
+            @checkout_steps ||= ActiveSupport::OrderedHash.new
+          end
+
+          def self.add_transition(options)
+            self.next_event_transitions << { options.delete(:from) => options.delete(:to) }.merge(options)
+          end
+
+          def checkout_steps
+            checkout_steps = []
+            # TODO: replace this with each_with_object once Ruby 1.9 is standard
+            self.class.checkout_steps.each do |step, options|
+              if options[:if]
+                next unless options[:if].call(self)
+              end
+              checkout_steps << step
+            end
+            checkout_steps.map(&:to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree/payment.rb

@@ -1,11 +1,11 @@
 module Spree
   class Payment < ActiveRecord::Base
     include Spree::Payment::Processing
-    belongs_to :order, :class_name => "Spree::Order"
+    belongs_to :order
     belongs_to :source, :polymorphic => true, :validate => true
-    belongs_to :payment_method, :class_name => "Spree::PaymentMethod"
+    belongs_to :payment_method
 
-    has_many :offsets, :class_name => 'Spree::Payment', :foreign_key => 'source_id', :conditions => "source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'"
+    has_many :offsets, :class_name => "Spree::Payment", :foreign_key => :source_id, :conditions => "source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'"
     has_many :log_entries, :as => :source
 
     after_save :create_payment_profile, :if => :profiles_supported?
@@ -18,7 +18,7 @@ module Spree
 
     attr_accessible :amount, :payment_method_id, :source_attributes
 
-    scope :from_creditcard, where(:source_type => 'Spree::Creditcard')
+    scope :from_credit_card, where(:source_type => 'Spree::CreditCard')
     scope :with_state, lambda { |s| where(:state => s) }
     scope :completed, with_state('completed')
     scope :pending, with_state('pending')
@@ -32,7 +32,7 @@ module Spree
       end
       # When processing during checkout fails
       event :failure do
-        transition :from => ['processing', 'pending'], :to => 'failed'
+        transition :from => 'processing', :to => 'failed'
       end
       # With card payments this represents authorizing the payment
       event :pend do
@@ -90,7 +90,7 @@ module Spree
       end
 
       def create_payment_profile
-        return unless source.is_a?(Creditcard) && source.number && !source.has_payment_profile?
+        return unless source.is_a?(CreditCard) && source.number && !source.has_payment_profile?
         payment_method.create_profile(self)
       rescue ActiveMerchant::ConnectionError => e
         gateway_error e

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

@@ -32,8 +32,8 @@ module Spree
           check_environment
 
           if payment_method.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
+            # Gateways supporting payment profiles will need access to credit card object because this stores the payment profile information
+            # so supply the authorization itself as well as the credit card, rather than just the authorization code
             response = payment_method.capture(self, source, gateway_options)
           else
             # Standard ActiveMerchant capture usage
@@ -47,13 +47,12 @@ module Spree
       end
 
       def void_transaction!
-        return true if void?
         protect_from_connection_error do
           check_environment
 
           if payment_method.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
+            # Gateways supporting payment profiles will need access to credit card object because this stores the payment profile information
+            # so supply the authorization itself as well as the credit card, rather than just the authorization code
             response = payment_method.void(self.response_code, source, gateway_options)
           else
             # Standard ActiveMerchant void usage
@@ -105,40 +104,8 @@ module Spree
       credit!(amount)
     end
 
-    def gateway_options
-      options = { :email    => order.email,
-                  :customer => order.email,
-                  :ip       => '192.168.1.100', # TODO: Use an actual IP
-                  :order_id => order.number }
-
-      options.merge!({ :shipping => order.ship_total * 100,
-                       :tax      => order.tax_total * 100,
-                       :subtotal => order.item_total * 100 })
-      
-      options.merge!({ :currency => payment_method.preferences[:currency_code] }) if payment_method && payment_method.preferences[:currency_code]
-
-      options.merge!({ :billing_address  => order.bill_address.try(:active_merchant_hash),
-                      :shipping_address => order.ship_address.try(:active_merchant_hash) })
-
-      options.merge!(:discount => promo_total) if respond_to?(:promo_total)
-      options
-    end
-
     private
 
-    def gateway_error(error)
-      if error.is_a? ActiveMerchant::Billing::Response
-        text = error.params['message'] || error.params['response_reason_text'] || error.message
-      elsif error.is_a? ActiveMerchant::ConnectionError
-        text = I18n.t(:unable_to_connect_to_gateway)
-      else
-        text = error.to_s
-      end
-      logger.error(I18n.t(:gateway_error))
-      logger.error("  #{error.to_yaml}")
-      raise Core::GatewayError.new(text)
-    end
-
     def gateway_action(source, action, success_state)
       protect_from_connection_error do
         check_environment
@@ -160,7 +127,7 @@ module Spree
         end
         self.send("#{success_state}!")
       else
-        self.send("#{failure_state}!")
+        self.send(failure_state)
         gateway_error(response)
       end
     end
@@ -169,6 +136,22 @@ module Spree
       log_entries.create({:details => response.to_yaml}, :without_protection => true)
     end
 
+    def gateway_options
+      options = { :email    => order.email,
+                  :customer => order.email,
+                  :ip       => '192.168.1.100', # TODO: Use an actual IP
+                  :order_id => order.number }
+
+      options.merge!({ :shipping => order.ship_total * 100,
+                       :tax      => order.tax_total * 100,
+                       :subtotal => order.item_total * 100 })
+      
+      options.merge!({ :currency => payment_method.preferences[:currency_code] }) if payment_method && payment_method.preferences[:currency_code]
+
+      options.merge({ :billing_address  => order.bill_address.try(:active_merchant_hash),
+                      :shipping_address => order.ship_address.try(:active_merchant_hash) })
+    end
+
     def protect_from_connection_error
       begin
         yield
@@ -181,6 +164,19 @@ module Spree
       log_entries.create({:details => response.to_yaml}, :without_protection => true)
     end
 
+    def gateway_error(error)
+      if error.is_a? ActiveMerchant::Billing::Response
+        text = error.params['message'] || error.params['response_reason_text'] || error.message
+      elsif error.is_a? ActiveMerchant::ConnectionError
+        text = I18n.t(:unable_to_connect_to_gateway)
+      else
+        text = error.to_s
+      end
+      logger.error(I18n.t(:gateway_error))
+      logger.error("  #{error.to_yaml}")
+      raise Core::GatewayError.new(text)
+    end
+
     # 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

data/app/models/spree/payment_method.rb

@@ -16,7 +16,7 @@ module Spree
     end
 
     # The class that will process payments for this payment type, used for @payment.source
-    # e.g. Creditcard in the case of a the Gateway payment type
+    # e.g. CreditCard in the case of a the Gateway payment type
     # nil means the payment method doesn't require a source e.g. check
     def payment_source_class
       raise 'You must implement payment_source_class method for this gateway.'
@@ -27,7 +27,7 @@ module Spree
     end
 
     def self.active?
-      self.count(:conditions => { :type => self.to_s, :environment => Rails.env, :active => true }) > 0
+      where(:type => self.to_s, :environment => Rails.env, :active => true).count > 0
     end
 
     def method_type

data/app/models/spree/preference.rb

@@ -21,6 +21,8 @@ class Spree::Preference < ActiveRecord::Base
         self[:value].to_i
       when :boolean
         (self[:value].to_s =~ /^[t|1]/i) != nil
+      else
+        self[:value].is_a?(String) ? YAML.load(self[:value]) : self[:value]
       end
     else
       self[:value]

data/app/models/spree/preferences/preferable_class_methods.rb

@@ -15,8 +15,6 @@ module Spree::Preferences
         else
           if get_pending_preference(name)
             get_pending_preference(name)
-          elsif Spree::Preference.table_exists? && preference = Spree::Preference.find_by_name(name)
-            preference.value
           else
             send self.class.preference_default_getter_method(name)
           end

data/app/models/spree/preferences/store.rb

@@ -23,29 +23,11 @@ module Spree::Preferences
     end
 
     def exist?(key)
-      @cache.exist?(key) ||
-      should_persist? && Spree::Preference.where(:key => key).exists?
+      @cache.exist? key
     end
 
     def get(key)
-      # return the retrieved value, if it's in the cache
-      if (val = @cache.read(key)).present?
-        return val
-      end
-
-      return nil unless should_persist?
-
-      # If it's not in the cache, maybe it's in the database, but
-      # has been cleared from the cache
-
-      # does it exist in the database?
-      if preference = Spree::Preference.find_by_key(key)
-        # it does exist, so let's put it back into the cache
-        @cache.write(preference.key, preference.value)
-
-        # and return the value
-        preference.value
-      end
+      @cache.read(key)
     end
 
     def delete(key)
@@ -58,7 +40,7 @@ module Spree::Preferences
     def persist(cache_key, value, type)
       return unless should_persist?
 
-      preference = Spree::Preference.find_or_initialize_by_key(cache_key)
+      preference = Spree::Preference.where(:key => cache_key).first_or_initialize
       preference.value = value
       preference.value_type = type
       preference.save

data/app/models/spree/product.rb

@@ -30,19 +30,8 @@ module Spree
     belongs_to :shipping_category
 
     has_one :master,
-      :class_name => 'Spree::Variant',
-      :conditions => { :is_master => true },
-      :dependent => :destroy
-
-    has_many :variants,
-      :class_name => 'Spree::Variant',
-      :conditions => { :is_master => false, :deleted_at => nil },
-      :order => "#{::Spree::Variant.quoted_table_name}.position ASC"
-
-    has_many :variants_including_master,
-      :class_name => 'Spree::Variant',
-      :conditions => { :deleted_at => nil },
-      :dependent => :destroy
+      :class_name => "Spree::Variant",
+      :conditions => { :is_master => true }
 
     delegate_belongs_to :master, :sku, :price, :weight, :height, :width, :depth, :is_master
     delegate_belongs_to :master, :cost_price if Variant.table_exists? && Variant.column_names.include?('cost_price')
@@ -54,13 +43,33 @@ module Spree
     after_save :save_master
     after_save :set_master_on_hand_to_zero_when_product_has_variants
 
-    delegate :images, :to => :master, :prefix => true
-    alias_method :images, :master_images
+    has_many :variants,
+      :class_name => "Spree::Variant",
+      :conditions => { :is_master => false, :deleted_at => nil },
+      :order => 'position ASC'
+
+    has_many :variants_including_master,
+      :class_name => "Spree::Variant",
+      :conditions => { :deleted_at => nil },
+      :dependent => :destroy
 
-    has_many :variant_images, :source => :images, :through => :variants_including_master, :order => :position
+    has_many :variants_with_only_master,
+      :class_name => "Spree::Variant",
+      :conditions => { :is_master => true, :deleted_at => nil },
+      :dependent => :destroy
 
     accepts_nested_attributes_for :variants, :allow_destroy => true
 
+    def variant_images
+      Image.joins("LEFT JOIN #{Variant.quoted_table_name} ON #{Variant.quoted_table_name}.id = #{Spree::Asset.quoted_table_name}.viewable_id").
+      where("(#{Spree::Asset.quoted_table_name}.viewable_type = ? AND #{Spree::Asset.quoted_table_name}.viewable_id = ?) OR
+             (#{Spree::Asset.quoted_table_name}.viewable_type = ? AND #{Spree::Asset.quoted_table_name}.viewable_id = ?)", Variant.name, self.master.id, Product.name, self.id).
+      order("#{Spree::Asset.quoted_table_name}.position").
+      extend(Spree::Core::RelationSerialization)
+    end
+
+    alias_method :images, :variant_images
+
     validates :name, :price, :permalink, :presence => true
 
     attr_accessor :option_values_hash
@@ -69,7 +78,7 @@ module Spree
                     :meta_keywords, :price, :sku, :deleted_at, :prototype_id,
                     :option_values_hash, :on_hand, :weight, :height, :width, :depth,
                     :shipping_category_id, :tax_category_id, :product_properties_attributes,
-                    :variants_attributes, :taxon_ids
+                    :variants_attributes, :taxon_ids, :option_type_ids
 
     attr_accessible :cost_price if Variant.table_exists? && Variant.column_names.include?('cost_price')
 
@@ -82,24 +91,23 @@ module Spree
 
     after_initialize :ensure_master
 
-    def variants_with_only_master
-      ActiveSupport::Deprecation.warn("[SPREE] Spree::Product#variants_with_only_master will be deprecated in Spree 1.3. Please use Spree::Product#master instead.")
-      master
+    def ensure_master
+      return unless new_record?
+      self.master ||= Variant.new
     end
 
-
     def to_param
       permalink.present? ? permalink : (permalink_was || name.to_s.to_url)
     end
 
     # returns true if the product has any variants (the master variant is not a member of the variants array)
     def has_variants?
-      variants.any?
+      variants.exists?
     end
 
     # returns the number of inventory units "on_hand" for this product
     def on_hand
-      has_variants? ? variants.inject(0) { |sum, v| sum + v.on_hand } : master.on_hand
+      has_variants? ? variants.sum(&:on_hand) : master.on_hand
     end
 
     # adjusts the "on_hand" inventory level for the product up or down to match the given new_level
@@ -109,8 +117,9 @@ module Spree
     end
 
     # Returns true if there are inventory units (any variant) with "on_hand" state for this product
+    # Variants take precedence over master
     def has_stock?
-      master.in_stock? || variants.any?(&:in_stock?)
+      has_variants? ? variants.any?(&:in_stock?) : master.in_stock?
     end
 
     def tax_category
@@ -121,13 +130,6 @@ module Spree
       end
     end
 
-    # override the delete method to set deleted_at value
-    # instead of actually deleting the product.
-    def delete
-      self.update_column(:deleted_at, Time.now)
-      variants_including_master.update_all(:deleted_at => Time.now)
-    end
-
     # Adding properties and option types on creation based on a chosen prototype
     attr_reader :prototype_id
     def prototype_id=(value)
@@ -202,14 +204,15 @@ module Spree
     end
 
     def set_property(property_name, property_value)
-      prop = Spree::Property.find_or_initialize_by_name(property_name) do |p|
-        p.presentation = property_name
-        p.save!
+      ActiveRecord::Base.transaction do
+        property = Property.where(:name => property_name).first_or_initialize
+        property.presentation = property_name
+        property.save!
+
+        product_property = ProductProperty.where(:product_id => id, :property_id => property.id).first_or_initialize
+        product_property.value = property_value
+        product_property.save!
       end
-
-      prod_prop = Spree::ProductProperty.find_or_initialize_by_product_id_and_property_id(self.id, prop.id)
-      prod_prop.value = property_value
-      prod_prop.save!
     end
 
     private
@@ -257,11 +260,6 @@ module Spree
       def save_master
         master.save if master && (master.changed? || master.new_record?)
       end
-
-      def ensure_master
-        return unless new_record?
-        self.master ||= Variant.new
-      end
   end
 end