spree_core 1.3.5 → 2.0.0.rc1

data/app/models/spree/promotion_action.rb

@@ -0,0 +1,19 @@
+# Base class for all types of promotion action.
+# PromotionActions perform the necessary tasks when a promotion is activated by an event and determined to be eligible.
+module Spree
+  class PromotionAction < ActiveRecord::Base
+    belongs_to :promotion, foreign_key: 'activator_id', class_name: 'Spree::Promotion'
+
+    scope :of_type, ->(t) { where(type: t) }
+
+    attr_accessible :line_items_string
+
+    # This method should be overriden in subclass
+    # Updates the state of the order or performs some other action depending on the subclass
+    # options will contain the payload from the event that activated the promotion. This will include
+    # the key :user which allows user based actions to be performed in addition to actions on the order
+    def perform(options = {})
+      raise 'perform should be implemented in a sub-class of PromotionAction'
+    end
+  end
+end

data/app/models/spree/promotion_action_line_item.rb

@@ -0,0 +1,8 @@
+module Spree
+  class PromotionActionLineItem < ActiveRecord::Base
+    belongs_to :promotion_action, class_name: 'Spree::Promotion::Actions::CreateLineItems'
+    belongs_to :variant, class_name: "Spree::Variant"
+
+    attr_accessible :quantity, :variant_id
+  end
+end

data/app/models/spree/promotion_rule.rb

@@ -0,0 +1,25 @@
+# Base class for all promotion rules
+module Spree
+  class PromotionRule < ActiveRecord::Base
+    belongs_to :promotion, foreign_key: 'activator_id', class_name: 'Spree::Promotion'
+
+    scope :of_type, ->(t) { where(type: t) }
+
+    validate :promotion, presence: true
+    validate :unique_per_activator, on: :create
+
+    attr_accessible :preferred_operator, :preferred_amount, :product, :product_ids_string, :preferred_match_policy
+
+    def eligible?(order, options = {})
+      raise 'eligible? should be implemented in a sub-class of Promotion::PromotionRule'
+    end
+
+    private
+    def unique_per_activator
+      if Spree::PromotionRule.exists?(activator_id: activator_id, type: self.class.name)
+        errors[:base] << "Promotion already contains this rule type"
+      end
+    end
+ 
+  end
+end

data/app/models/spree/property.rb

@@ -1,20 +1,21 @@
 module Spree
   class Property < ActiveRecord::Base
-    has_and_belongs_to_many :prototypes, :join_table => :spree_properties_prototypes
+    has_and_belongs_to_many :prototypes, join_table: 'spree_properties_prototypes'
 
-    has_many :product_properties, :dependent => :destroy
-    has_many :products, :through => :product_properties
+    has_many :product_properties, dependent: :destroy
+    has_many :products, through: :product_properties
 
     attr_accessible :name, :presentation
 
-    validates :name, :presentation, :presence => true
+    validates :name, :presentation, presence: true
+
+    scope :sorted, -> { order(:name) }
 
     def self.find_all_by_prototype(prototype)
       id = prototype
-      if prototype.class == Prototype
-        id = prototype.id
-      end
-      joins("LEFT JOIN properties_prototypes ON property_id = #{self.table_name}.id").where(:prototype_id => id)
+      id = prototype.id if prototype.class == Prototype
+      joins("LEFT JOIN properties_prototypes ON property_id = #{self.table_name}.id").
+        where(prototype_id: id)
     end
   end
 end

data/app/models/spree/prototype.rb

@@ -1,10 +1,10 @@
 module Spree
   class Prototype < ActiveRecord::Base
-    has_and_belongs_to_many :properties, :join_table => :spree_properties_prototypes
-    has_and_belongs_to_many :option_types, :join_table => :spree_option_types_prototypes
+    has_and_belongs_to_many :properties, join_table: :spree_properties_prototypes
+    has_and_belongs_to_many :option_types, join_table: :spree_option_types_prototypes
 
     attr_accessible :name, :property_ids, :option_type_ids
 
-    validates :name, :presence => true
+    validates :name, presence: true
   end
 end

data/app/models/spree/return_authorization.rb

@@ -1,25 +1,26 @@
 module Spree
   class ReturnAuthorization < ActiveRecord::Base
-    belongs_to :order
+    belongs_to :order, class_name: 'Spree::Order'
 
     has_many :inventory_units
+    has_one :stock_location
     before_create :generate_number
     before_save :force_positive_amount
 
-    validates :order, :presence => true
-    validates :amount, :numericality => true
+    validates :order, presence: true
+    validates :amount, numericality: true
     validate :must_have_shipped_units
 
-    attr_accessible :amount, :reason
+    attr_accessible :amount, :reason, :stock_location_id
 
-    state_machine :initial => 'authorized' do
-      after_transition :to => 'received', :do => :process_return
+    state_machine initial: 'authorized' do
+      after_transition to: 'received', do: :process_return
 
       event :receive do
-        transition :to => 'received', :from => 'authorized', :if => :allow_receive?
+        transition to: 'received', from: 'authorized', if: :allow_receive?
       end
       event :cancel do
-        transition :to => 'canceled', :from => 'authorized'
+        transition to: 'canceled', from: 'authorized'
       end
     end
 
@@ -28,12 +29,13 @@ module Spree
     end
 
     def display_amount
-      Spree::Money.new(amount, { :currency => currency })
+      Spree::Money.new(amount, { currency: currency })
     end
 
     def add_variant(variant_id, quantity)
-      order_units = order.inventory_units.group_by(&:variant_id)
+      order_units = returnable_inventory.group_by(&:variant_id)
       returned_units = inventory_units.group_by(&:variant_id)
+      return false if order_units.empty?
 
       count = 0
 
@@ -44,7 +46,7 @@ module Spree
           next unless inventory_unit.return_authorization.nil? && count < quantity
 
           inventory_unit.return_authorization = self
-          inventory_unit.save!
+          inventory_unit.return!
 
           count += 1
         end
@@ -58,9 +60,13 @@ module Spree
       order.authorize_return! if inventory_units.reload.size > 0 && !order.awaiting_return?
     end
 
+    def returnable_inventory
+      order.shipped_shipments.collect{|s| s.inventory_units.all}.flatten
+    end
+
     private
       def must_have_shipped_units
-        errors.add(:order, I18n.t(:has_no_shipped_units)) if order.nil? || !order.inventory_units.any?(&:shipped?)
+        errors.add(:order, Spree.t(:has_no_shipped_units)) if order.nil? || !order.shipped_shipments.any?
       end
 
       def generate_number
@@ -69,17 +75,22 @@ module Spree
         record = true
         while record
           random = "RMA#{Array.new(9){rand(9)}.join}"
-          record = self.class.where(:number => random).first
+          record = self.class.where(number: random).first
         end
         self.number = random
       end
 
       def process_return
-        inventory_units.each &:return!
-        credit = Adjustment.new(:amount => amount.abs * -1, :label => I18n.t(:rma_credit))
+        inventory_units.each do |iu|
+          iu.return!
+          Spree::StockMovement.create!(stock_item_id: iu.find_stock_item.id, quantity: 1)
+        end
+
+        credit = Adjustment.new(amount: amount.abs * -1, label: Spree.t(:rma_credit))
         credit.source = self
         credit.adjustable = order
         credit.save
+
         order.return if inventory_units.all?(&:returned?)
       end
 

data/app/models/spree/role.rb

@@ -2,6 +2,6 @@ module Spree
   class Role < ActiveRecord::Base
     attr_accessible :name
 
-    has_and_belongs_to_many :users, :join_table => 'spree_roles_users', :class_name => Spree.user_class.to_s
+    has_and_belongs_to_many :users, join_table: 'spree_roles_users', class_name: Spree.user_class.to_s
   end
 end

data/app/models/spree/shipment.rb

@@ -2,34 +2,68 @@ require 'ostruct'
 
 module Spree
   class Shipment < ActiveRecord::Base
-    belongs_to :order
-    belongs_to :shipping_method
-    belongs_to :address
+    belongs_to :order, class_name: 'Spree::Order'
+    belongs_to :address, class_name: 'Spree::Address'
+    belongs_to :stock_location, class_name: 'Spree::StockLocation'
 
-    has_many :state_changes, :as => :stateful
-    has_many :inventory_units, :dependent => :nullify
-    has_one :adjustment, :as => :source, :dependent => :destroy
+    has_many :shipping_rates
+    has_many :shipping_methods, through: :shipping_rates
+    has_many :state_changes, as: :stateful
+    has_many :inventory_units, dependent: :destroy
+    has_one :adjustment, as: :source, dependent: :destroy
 
     before_create :generate_shipment_number
     after_save :ensure_correct_adjustment, :update_order
 
     attr_accessor :special_instructions
-
-    attr_accessible :order, :shipping_method, :special_instructions,
-                    :shipping_method_id, :tracking, :address, :inventory_units
+    attr_accessible :order, :special_instructions, :stock_location_id,
+                    :tracking, :address, :inventory_units, :selected_shipping_rate_id
 
     accepts_nested_attributes_for :address
     accepts_nested_attributes_for :inventory_units
 
-    validates :inventory_units, :presence => true, :if => :require_inventory
-    validates :shipping_method, :presence => true
+    make_permalink field: :number
+
+    scope :shipped, -> { with_state('shipped') }
+    scope :ready,   -> { with_state('ready') }
+    scope :pending, -> { with_state('pending') }
+    scope :with_state, ->(*s) { where(state: s) }
+    scope :trackable, -> { where("tracking IS NOT NULL AND tracking != ''") }
+
+    # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
+    state_machine initial: :pending, use_transactions: false do
+      event :ready do
+        transition from: :pending, to: :ready, if: lambda { |shipment|
+          # Fix for #2040
+          shipment.determine_state(shipment.order) == :ready
+        }
+      end
 
-    make_permalink :field => :number
+      event :pend do
+        transition from: :ready, to: :pending
+      end
 
-    scope :with_state, lambda { |s| where(:state => s) }
-    scope :shipped, with_state('shipped')
-    scope :ready, with_state('ready')
-    scope :pending, with_state('pending')
+      event :ship do
+        transition from: :ready, to: :shipped
+      end
+      after_transition to: :shipped, do: :after_ship
+
+      event :cancel do
+        transition to: :canceled, from: [:pending, :ready]
+      end
+      after_transition to: :canceled, do: :after_cancel
+
+      event :resume do
+        transition from: :canceled, to: :ready, if: lambda { |shipment|
+          shipment.determine_state(shipment.order) == :ready
+        }
+        transition from: :canceled, to: :pending, if: lambda { |shipment|
+          shipment.determine_state(shipment.order) == :ready
+        }
+        transition from: :canceled, to: :pending
+      end
+      after_transition from: :canceled, to: [:pending, :ready], do: :after_resume
+    end
 
     def to_param
       number if number
@@ -37,13 +71,56 @@ module Spree
       number.to_s.to_url.upcase
     end
 
+    def backordered?
+      inventory_units.any? { |inventory_unit| inventory_unit.backordered? }
+    end
+
     def shipped=(value)
       return unless value == '1' && shipped_at.nil?
       self.shipped_at = Time.now
     end
 
+    def shipping_method
+      selected_shipping_rate.try(:shipping_method) || shipping_rates.first.try(:shipping_method)
+    end
+
+    def add_shipping_method(shipping_method, selected = false)
+      shipping_rates.create(shipping_method: shipping_method, selected: selected)
+    end
+
+    def selected_shipping_rate
+      shipping_rates.where(selected: true).first
+    end
+
+    def selected_shipping_rate_id
+      selected_shipping_rate.try(:id)
+    end
+
+    def selected_shipping_rate_id=(id)
+      shipping_rates.update_all(selected: false)
+      shipping_rates.update(id, selected: true)
+      self.save!
+    end
+
+    def refresh_rates
+      return shipping_rates if shipped?
+
+      shipping_method_id = shipping_method.try(:id)
+      self.shipping_rates = Stock::Estimator.new(order).shipping_rates(to_package)
+
+
+      if shipping_method_id
+        selected_rate = shipping_rates.detect { |rate|
+          rate.shipping_method_id == shipping_method_id
+        }
+        self.selected_shipping_rate_id = selected_rate.id if selected_rate
+      end
+
+      shipping_rates
+    end
+
     def currency
-      order.nil? ? Spree::Config[:currency] : order.currency
+      order ? order.currency : Spree::Config[:currency]
     end
 
     # The adjustment amount associated with this shipment (if any.)  Returns only the first adjustment to match
@@ -55,27 +132,25 @@ module Spree
     alias_method :amount, :cost
 
     def display_cost
-      Spree::Money.new(cost, { :currency => currency })
+      Spree::Money.new(cost, { currency: currency })
     end
 
     alias_method :display_amount, :display_cost
 
-    # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
-    state_machine :initial => 'pending', :use_transactions => false do
-      event :ready do
-        transition :from => 'pending', :to => 'ready', :if => lambda { |shipment|
-          # Fix for #2040
-          shipment.determine_state(shipment.order) == 'ready'
-        }
-      end
-      event :pend do
-        transition :from => 'ready', :to => 'pending'
-      end
-      event :ship do
-        transition :from => 'ready', :to => 'shipped'
-      end
+    def item_cost
+      line_items.map(&:amount).sum
+    end
+
+    def display_item_cost
+      Spree::Money.new(item_cost, { currency: currency })
+    end
+
+    def total_cost
+      cost + item_cost
+    end
 
-      after_transition :to => 'shipped', :do => :after_ship
+    def display_total_cost
+      Spree::Money.new(total_cost, { currency: currency })
     end
 
     def editable_by?(user)
@@ -83,8 +158,10 @@ module Spree
     end
 
     def manifest
-      inventory_units.group_by(&:variant).map do |i|
-        OpenStruct.new(:variant => i.first, :quantity => i.last.length)
+      inventory_units.group_by(&:variant).map do |variant, units|
+        states = {}
+        units.group_by(&:state).each { |state, iu| states[state] = iu.count }
+        OpenStruct.new(variant: variant, quantity: units.length, states: states)
       end
     end
 
@@ -96,13 +173,26 @@ module Spree
       end
     end
 
+    def finalize!
+      InventoryUnit.finalize_units!(inventory_units)
+      manifest.each { |item| manifest_unstock(item) }
+    end
+
+    def after_cancel
+      manifest.each { |item| manifest_restock(item) }
+    end
+
+    def after_resume
+      manifest.each { |item| manifest_unstock(item) }
+    end
+
     # Updates various aspects of the Shipment while bypassing any callbacks.  Note that this method takes an explicit reference to the
     # Order object.  This is necessary because the association actually has a stale (and unsaved) copy of the Order and so it will not
     # yield the correct results.
     def update!(order)
       old_state = state
       new_state = determine_state(order)
-      update_column 'state', new_state
+      update_column :state, new_state
       after_ship if new_state == 'shipped' and old_state != 'shipped'
     end
 
@@ -112,43 +202,66 @@ module Spree
     # shipped    if already shipped (ie. does not change the state)
     # ready      all other cases
     def determine_state(order)
+      return 'canceled' if order.canceled?
       return 'pending' unless order.can_ship?
       return 'pending' if inventory_units.any? &:backordered?
       return 'shipped' if state == 'shipped'
       order.paid? ? 'ready' : 'pending'
     end
 
+    def tracking_url
+      @tracking_url ||= shipping_method.build_tracking_url(tracking)
+    end
+
+    def include?(variant)
+      inventory_units_for(variant).present?
+    end
+
+    def inventory_units_for(variant)
+      inventory_units.group_by(&:variant_id)[variant.id] || []
+    end
+
+    def to_package
+      package = Stock::Package.new(stock_location, order)
+      inventory_units.each do |inventory_unit|
+        package.add inventory_unit.variant, 1, inventory_unit.state
+      end
+      package
+    end
+
     private
+
+      def manifest_unstock(item)
+        stock_location.unstock item.variant, item.quantity, self
+      end
+
+      def manifest_restock(item)
+        stock_location.restock item.variant, item.quantity, self
+      end
+
       def generate_shipment_number
         return number unless number.blank?
         record = true
         while record
           random = "H#{Array.new(11) { rand(9) }.join}"
-          record = self.class.where(:number => random).first
+          record = self.class.where(number: random).first
         end
         self.number = random
       end
 
       def description_for_shipping_charge
-        "#{I18n.t(:shipping)} (#{shipping_method.name})"
+        "#{Spree.t(:shipping)} (#{shipping_method.name})"
       end
 
       def validate_shipping_method
         unless shipping_method.nil?
-          errors.add :shipping_method, I18n.t(:is_not_available_to_shipment_address) unless shipping_method.zone.include?(address)
+          errors.add :shipping_method, Spree.t(:is_not_available_to_shipment_address) unless shipping_method.include?(address)
         end
       end
 
-      # Determines whether or not inventory units should be associated with the shipment.  This is always +false+ when
-      # +Spree::Config[:track_inventory_levels]+ is set to +false.+  Otherwise its +true+ whenever the order is completed
-      # (and not canceled.)
-      def require_inventory
-        return false unless Spree::Config[:track_inventory_levels]
-        order.completed? && !order.canceled?
-      end
-
       def after_ship
         inventory_units.each &:ship!
+        adjustment.finalize!
         send_shipped_email
         touch :shipped_at
       end
@@ -160,10 +273,12 @@ module Spree
       def ensure_correct_adjustment
         if adjustment
           adjustment.originator = shipping_method
-          adjustment.label = shipping_method.adjustment_label
-          adjustment.save
-        else
-          shipping_method.create_adjustment(shipping_method.adjustment_label, order, self, true)
+          adjustment.label = shipping_method.name
+          adjustment.amount = selected_shipping_rate.cost if adjustment.open?
+          adjustment.save!
+          adjustment.reload
+        elsif selected_shipping_rate_id
+          shipping_method.create_adjustment shipping_method.name, order, self, true, "open"
           reload #ensure adjustment is present on later saves
         end
       end

data/app/models/spree/shipping_calculator.rb

@@ -0,0 +1,25 @@
+module Spree
+  class ShippingCalculator < Calculator
+    belongs_to :calculable, polymorphic: true
+
+    def compute(package_or_shipment)
+      package = package_or_shipment.respond_to?(:to_package) ?
+                  package_or_shipment.to_package : package_or_shipment
+      compute_package package
+    end
+
+    def compute_package(package)
+      raise(NotImplementedError, 'please use concrete calculator')
+    end
+
+    def available?(package)
+      true
+    end
+
+    private
+    def total(content_items)
+      content_items.sum { |item| item.quantity * item.variant.price }
+    end
+  end
+end
+

data/app/models/spree/shipping_category.rb

@@ -1,8 +1,9 @@
 module Spree
   class ShippingCategory < ActiveRecord::Base
-    validates :name, :presence => true
+    validates :name, presence: true
     has_many :products
-    has_many :shipping_methods
+    has_many :shipping_method_categories
+    has_many :shipping_methods, through: :shipping_method_categories
 
     attr_accessible :name
   end

data/app/models/spree/shipping_method.rb

@@ -1,67 +1,59 @@
 module Spree
   class ShippingMethod < ActiveRecord::Base
+    include Spree::Core::CalculatedAdjustments
     DISPLAY = [:both, :front_end, :back_end]
 
-    default_scope where(:deleted_at => nil)
+    default_scope where(deleted_at: nil)
 
     has_many :shipments
-    validates :name, :zone, :presence => true
+    has_many :shipping_method_categories
+    has_many :shipping_categories, through: :shipping_method_categories
 
-    belongs_to :shipping_category
-    belongs_to :zone
+    has_and_belongs_to_many :zones
 
-    attr_accessible :name, :zone_id, :display_on, :shipping_category_id,
-                    :match_none, :match_one, :match_all
+    attr_accessible :name, :zones, :display_on, :shipping_category_id,
+                    :match_none, :match_one, :match_all, :tracking_url
 
-    calculated_adjustments
+    validates :name, presence: true
 
-    def adjustment_label
-      I18n.t(:shipping)
-    end
-
-    def available?(order, display_on = nil)
-      displayable?(display_on) && calculator.available?(order)
-    end
+    validate :at_least_one_shipping_category
 
-    def displayable?(display_on)
-      (self.display_on == display_on.to_s || self.display_on.blank?)
+    def adjustment_label
+      Spree.t(:shipping)
     end
 
-    def within_zone?(order)
-      zone && zone.include?(order.ship_address)
+    def zone
+      raise "DEPRECATION WARNING: ShippingMethod#zone is no longer correct. Multiple zones need to be supported"
+      Rails.logger.error "DEPRECATION WARNING: ShippingMethod#zone is no longer correct. Multiple zones need to be supported"
+      zones.first
     end
 
-    def available_to_order?(order, display_on= nil)
-      available?(order, display_on) &&
-      within_zone?(order) &&
-      category_match?(order) &&
-      currency_match?(order)
+    def zone=(zone)
+      p "DEPRECATION WARNING: ShippingMethod#zone is no longer correct. Multiple zones need to be supported"
+      Rails.logger.error "DEPRECATION WARNING: ShippingMethod#zone= is no longer correct. Multiple zones need to be supported"
+      zones = zone
     end
 
-    # Indicates whether or not the category rules for this shipping method
-    # are satisfied (if applicable)
-    def category_match?(order)
-      return true if shipping_category.nil?
-
-      if match_all
-        order.products.all? { |p| p.shipping_category == shipping_category }
-      elsif match_one
-        order.products.any? { |p| p.shipping_category == shipping_category }
-      elsif match_none
-        order.products.all? { |p| p.shipping_category != shipping_category }
+    def include?(address)
+      return false unless address
+      zones.any? do |zone|
+        zone.include?(address)
       end
     end
 
-    def currency_match?(order)
-      calculator_currency.nil? || calculator_currency == order.currency
+    def build_tracking_url(tracking)
+      tracking_url.gsub(/:tracking/, tracking) unless tracking.blank? || tracking_url.blank?
     end
 
-    def calculator_currency
-      calculator.preferences[:currency]
+    def self.calculators
+      spree_calculators.send(model_name_without_spree_namespace).select{|c| c.name.start_with?("Spree::Calculator::Shipping::")}
     end
 
-    def self.all_available(order, display_on = nil)
-      all.select { |method| method.available_to_order?(order,display_on) }
-    end
+    private
+      def at_least_one_shipping_category
+        if self.shipping_categories.empty?
+          self.errors[:base] << "You need to select at least one shipping category"
+        end
+      end
   end
 end

data/app/models/spree/shipping_method_category.rb

@@ -0,0 +1,6 @@
+module Spree
+  class ShippingMethodCategory < ActiveRecord::Base
+    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod'
+    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory'
+  end
+end