spree_core 2.1.12 → 2.2.0

data/app/models/spree/promotion_handler/page.rb

@@ -0,0 +1,24 @@
+module Spree
+  module PromotionHandler
+    class Page
+      attr_reader :order, :path
+
+      def initialize(order, path)
+        @order = order
+        @path = path.gsub(/\A\//, '')
+      end
+
+      def activate
+        if promotion && promotion.eligible?(order)
+          promotion.activate(:order => order)
+        end
+      end
+
+      private
+
+        def promotion
+          @promotion ||= Promotion.active.find_by(:path => path)
+        end
+    end
+  end
+end

data/app/models/spree/promotion_rule.rb

@@ -1,23 +1,31 @@
 # Base class for all promotion rules
 module Spree
   class PromotionRule < ActiveRecord::Base
-    belongs_to :promotion, foreign_key: 'activator_id', class_name: 'Spree::Promotion'
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules
 
     scope :of_type, ->(t) { where(type: t) }
 
     validate :promotion, presence: true
-    validate :unique_per_activator, on: :create
+    validate :unique_per_promotion, on: :create
 
-    def eligible?(order, options = {})
-      raise 'eligible? should be implemented in a sub-class of Promotion::PromotionRule'
+    def self.for(promotable)
+      all.select { |rule| rule.applicable?(promotable) }
+    end
+
+    def applicable?(promotable)
+      raise 'applicable? should be implemented in a sub-class of Spree::PromotionRule'
+    end
+
+    def eligible?(promotable, options = {})
+      raise 'eligible? should be implemented in a sub-class of Spree::PromotionRule'
     end
 
     private
-    def unique_per_activator
-      if Spree::PromotionRule.exists?(activator_id: activator_id, type: self.class.name)
+    def unique_per_promotion
+      if Spree::PromotionRule.exists?(promotion_id: promotion_id, type: self.class.name)
         errors[:base] << "Promotion already contains this rule type"
       end
     end
- 
+
   end
 end

data/app/models/spree/property.rb

@@ -2,7 +2,7 @@ module Spree
   class Property < ActiveRecord::Base
     has_and_belongs_to_many :prototypes, join_table: 'spree_properties_prototypes'
 
-    has_many :product_properties, dependent: :delete_all
+    has_many :product_properties, dependent: :delete_all, inverse_of: :property
     has_many :products, through: :product_properties
 
     validates :name, :presentation, presence: true

data/app/models/spree/return_authorization.rb

@@ -62,6 +62,11 @@ module Spree
       order.shipped_shipments.collect{|s| s.inventory_units.to_a}.flatten
     end
 
+    # Used when Adjustment#update! wants to update the related adjustmenrt
+    def compute_amount(*args)
+      amount.abs * -1
+    end
+
     private
 
       def must_have_shipped_units
@@ -82,10 +87,11 @@ module Spree
           Spree::StockMovement.create!(stock_item_id: stock_item.id, quantity: 1)
         end
 
-        credit = Adjustment.new(amount: amount.abs * -1, label: Spree.t(:rma_credit))
+        credit = Adjustment.new(amount: compute_amount, label: Spree.t(:rma_credit))
         credit.source = self
         credit.adjustable = order
         credit.save
+        order.update!
 
         order.return if inventory_units.all?(&:returned?)
       end

data/app/models/spree/shipment.rb

@@ -2,17 +2,19 @@ require 'ostruct'
 
 module Spree
   class Shipment < ActiveRecord::Base
-    belongs_to :order, class_name: 'Spree::Order', touch: true
-    belongs_to :address, class_name: 'Spree::Address'
+    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :shipments
+    belongs_to :address, class_name: 'Spree::Address', inverse_of: :shipments
     belongs_to :stock_location, class_name: 'Spree::StockLocation'
 
     has_many :shipping_rates, dependent: :delete_all
     has_many :shipping_methods, through: :shipping_rates
     has_many :state_changes, as: :stateful
-    has_many :inventory_units, dependent: :delete_all
-    has_one :adjustment, as: :source, dependent: :destroy
+    has_many :inventory_units, dependent: :delete_all, inverse_of: :shipment
+    has_many :adjustments, as: :adjustable, dependent: :delete_all
 
-    after_save :ensure_correct_adjustment, :update_order
+    after_save :update_adjustments
+
+    before_validation :set_cost_zero_when_nil
 
     attr_accessor :special_instructions
 
@@ -60,6 +62,14 @@ module Spree
         transition from: :canceled, to: :pending
       end
       after_transition from: :canceled, to: [:pending, :ready], do: :after_resume
+
+      after_transition do |shipment, transition|
+        shipment.state_changes.create!(
+          previous_state: transition.from,
+          next_state:     transition.to,
+          name:           'shipment',
+        )
+      end
     end
 
     def to_param
@@ -70,6 +80,10 @@ module Spree
       inventory_units.any? { |inventory_unit| inventory_unit.backordered? }
     end
 
+    def ready_or_pending?
+      self.ready? || self.pending?
+    end
+
     def shipped=(value)
       return unless value == '1' && shipped_at.nil?
       self.shipped_at = Time.now
@@ -97,6 +111,10 @@ module Spree
       self.save!
     end
 
+    def tax_category
+      selected_shipping_rate.try(:tax_rate).try(:tax_category)
+    end
+
     def refresh_rates
       return shipping_rates if shipped?
       return [] unless can_get_rates?
@@ -120,54 +138,59 @@ module Spree
       order ? order.currency : Spree::Config[:currency]
     end
 
-    # The adjustment amount associated with this shipment (if any.)  Returns only the first adjustment to match
-    # the shipment but there should never really be more than one.
-    def cost
-      adjustment ? adjustment.amount : 0
-    end
-
-    alias_method :amount, :cost
-
     def display_cost
       Spree::Money.new(cost, { currency: currency })
     end
-
-    alias_method :display_amount, :display_cost
+    alias display_amount display_cost
 
     def item_cost
       line_items.map(&:amount).sum
     end
 
-    def display_item_cost
-      Spree::Money.new(item_cost, { currency: currency })
+    def discounted_cost
+      cost + promo_total
+    end
+    alias discounted_amount discounted_cost
+
+    # Only one of either included_tax_total or additional_tax_total is set
+    # This method returns the total of the two. Saves having to check if 
+    # tax is included or additional.
+    def tax_total
+      included_tax_total + additional_tax_total
+    end
+
+    def final_price
+      discounted_cost + tax_total
     end
 
-    def total_cost
-      cost + item_cost
+    def display_discounted_cost
+      Spree::Money.new(discounted_cost, { currency: currency })
     end
 
-    def display_total_cost
-      Spree::Money.new(total_cost, { currency: currency })
+    def display_item_cost
+      Spree::Money.new(item_cost, { currency: currency })
     end
 
     def editable_by?(user)
       !shipped?
     end
 
+    ManifestItem = Struct.new(:line_item, :variant, :quantity, :states)
+
     def manifest
       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
+        units.group_by(&:line_item).map do |line_item, units|
+
+          states = {}
+          units.group_by(&:state).each { |state, iu| states[state] = iu.count }
+
+          ManifestItem.new(line_item, variant, units.length, states)
+        end
+      end.flatten
     end
 
     def line_items
-      if order.complete? and Spree::Config.track_inventory_levels
-        order.line_items.select { |li| !li.should_track_inventory? || inventory_units.pluck(:variant_id).include?(li.variant_id) }
-      else
-        order.line_items
-      end
+      inventory_units.includes(:line_item).map(&:line_item).uniq
     end
 
     def finalize!
@@ -189,7 +212,10 @@ module Spree
     def update!(order)
       old_state = state
       new_state = determine_state(order)
-      update_column :state, new_state
+      update_columns(
+        state: new_state,
+        updated_at: Time.now,
+      )
       after_ship if new_state == 'shipped' and old_state != 'shipped'
     end
 
@@ -215,19 +241,45 @@ module Spree
     end
 
     def inventory_units_for(variant)
-      inventory_units.group_by(&:variant_id)[variant.id] || []
+      inventory_units.where(variant_id: variant.id)
+    end
+
+    def inventory_units_for_item(line_item, variant = nil)
+      inventory_units.where(line_item_id: line_item.id, variant_id: line_item.variant.id || variant.id)
     end
 
     def to_package
       package = Stock::Package.new(stock_location, order)
-      inventory_units.includes(:variant).each do |inventory_unit|
-        package.add inventory_unit.variant, 1, inventory_unit.state_name
+      grouped_inventory_units = inventory_units.includes(:line_item).group_by do |iu|
+        [iu.line_item, iu.state_name]
+      end
+
+      grouped_inventory_units.each do |(line_item, state_name), inventory_units|
+        package.add line_item, inventory_units.count, state_name
       end
       package
     end
 
-    def set_up_inventory(state, variant, order)
-      self.inventory_units.create(variant_id: variant.id, state: state, order_id: order.id)
+    def set_up_inventory(state, variant, order, line_item)
+      self.inventory_units.create(
+        state: state,
+        variant_id: variant.id,
+        order_id: order.id,
+        line_item_id: line_item.id
+      )
+    end
+
+    def persist_cost
+      self.cost = selected_shipping_rate.cost
+      update_amounts
+    end
+
+    def update_amounts
+      self.update_columns(
+        cost: selected_shipping_rate.cost,
+        adjustment_total: adjustments.map(&:update!).compact.sum,
+        updated_at: Time.now,
+      )
     end
 
     private
@@ -250,32 +302,44 @@ module Spree
         "#{Spree.t(:shipping)} (#{shipping_method.name})"
       end
 
+      def validate_shipping_method
+        unless shipping_method.nil?
+          errors.add :shipping_method, Spree.t(:is_not_available_to_shipment_address) unless shipping_method.include?(address)
+        end
+      end
+
       def after_ship
         inventory_units.each &:ship!
-        adjustment.finalize!
         send_shipped_email
         touch :shipped_at
+        update_order_shipment_state
+      end
+
+      def update_order_shipment_state
+        new_state = OrderUpdater.new(order).update_shipment_state
+        order.update_columns(
+          shipment_state: new_state,
+          updated_at: Time.now,
+        )
       end
 
       def send_shipped_email
         ShipmentMailer.shipped_email(self.id).deliver
       end
 
-      def ensure_correct_adjustment
-        if adjustment
-          adjustment.originator = shipping_method
-          adjustment.label = shipping_method.adjustment_label
-          adjustment.amount = selected_shipping_rate.cost if adjustment.open?
-          adjustment.save!
-          adjustment.reload
-        elsif selected_shipping_rate_id
-          shipping_method.create_adjustment shipping_method.adjustment_label, order, self, true, "open"
-          reload #ensure adjustment is present on later saves
+      def set_cost_zero_when_nil
+        self.cost = 0 unless self.cost
+      end
+
+
+      def update_adjustments
+        if cost_changed? && state != 'shipped'
+          recalculate_adjustments
         end
       end
 
-      def update_order
-        order.update!
+      def recalculate_adjustments
+        Spree::ItemAdjustments.new(self).update
       end
 
       def can_get_rates?

data/app/models/spree/shipping_calculator.rb

@@ -1,13 +1,12 @@
 module Spree
   class ShippingCalculator < Calculator
-    def compute(package_or_shipment)
-      package = package_or_shipment.respond_to?(:to_package) ?
-                  package_or_shipment.to_package : package_or_shipment
-      compute_package package
+
+    def compute_shipment(shipment)
+      raise NotImplementedError, "Please implement 'compute_shipment(shipment)' in your calculator: #{self.class.name}"
     end
 
     def compute_package(package)
-      raise(NotImplementedError, 'please use concrete calculator')
+      raise NotImplementedError, "Please implement 'compute_package(package)' in your calculator: #{self.class.name}"
     end
 
     def available?(package)

data/app/models/spree/shipping_category.rb

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

data/app/models/spree/shipping_method.rb

@@ -1,28 +1,26 @@
 module Spree
   class ShippingMethod < ActiveRecord::Base
-    acts_as_paranoid
     include Spree::Core::CalculatedAdjustments
     DISPLAY = [:both, :front_end, :back_end]
 
     default_scope -> { where(deleted_at: nil) }
 
+    has_many :adjustments, as: :source
+    has_many :shipments
     has_many :shipping_method_categories, :dependent => :destroy
     has_many :shipping_categories, through: :shipping_method_categories
     has_many :shipping_rates, inverse_of: :shipping_method
-    has_many :shipments, :through => :shipping_rates
 
     has_and_belongs_to_many :zones, :join_table => 'spree_shipping_methods_zones',
                                     :class_name => 'Spree::Zone',
                                     :foreign_key => 'shipping_method_id'
 
+    belongs_to :tax_category, :class_name => 'Spree::TaxCategory'
+
     validates :name, presence: true
 
     validate :at_least_one_shipping_category
 
-    def adjustment_label
-      Spree.t(:shipping)
-    end
-
     def include?(address)
       return false unless address
       zones.any? do |zone|
@@ -44,7 +42,15 @@ module Spree
       self.display_on != "back_end"
     end
 
+    def tax_category
+      Spree::TaxCategory.unscoped { super }
+    end
+
     private
+      def compute_amount(calculable)
+        self.calculator.compute(calculable)
+      end
+
       def at_least_one_shipping_category
         if self.shipping_categories.empty?
           self.errors[:base] << "You need to select at least one shipping category"

data/app/models/spree/shipping_rate.rb

@@ -2,24 +2,44 @@ module Spree
   class ShippingRate < ActiveRecord::Base
     belongs_to :shipment, class_name: 'Spree::Shipment'
     belongs_to :shipping_method, class_name: 'Spree::ShippingMethod', inverse_of: :shipping_rates
+    belongs_to :tax_rate, class_name: 'Spree::TaxRate'
+
+    scope :with_shipping_method,
+      -> { includes(:shipping_method).
+           references(:shipping_method).
+           order("cost ASC") }
 
     delegate :order, :currency, to: :shipment
     delegate :name, to: :shipping_method
 
-    def display_price
-      if Spree::Config[:shipment_inc_vat]
-        price = (1 + Spree::TaxRate.default) * cost
-      else
-        price = cost
-      end
+    def display_base_price
+      Spree::Money.new(cost, currency: currency)
+    end
 
-      Spree::Money.new(price, { currency: currency })
+    def display_tax_amount
+      Spree::Money.new(tax_rate.calculator.compute_shipping_rate(self), currency: currency)
     end
 
+    def display_price
+      price = display_base_price.to_s
+      if tax_rate
+        amount = "#{display_tax_amount} #{tax_rate.name}"
+        if tax_rate.included_in_price?
+          price += " (incl. #{amount})"
+        else
+          price += " (+ #{amount})"
+        end
+      end
+      price
+    end
     alias_method :display_cost, :display_price
 
     def shipping_method
       Spree::ShippingMethod.unscoped { super }
     end
+
+    def tax_rate
+      Spree::TaxRate.unscoped { super }
+    end
   end
 end