solidus_core 2.3.1 → 2.4.0.beta1

data/app/models/spree/return_item/eligibility_validator/order_completed.rb

@@ -1,16 +1,20 @@
 module Spree
-  class ReturnItem::EligibilityValidator::OrderCompleted < Spree::ReturnItem::EligibilityValidator::BaseValidator
-    def eligible_for_return?
-      if @return_item.inventory_unit.order.completed?
-        return true
-      else
-        add_error(:order_not_completed, Spree.t('return_item_order_not_completed'))
-        return false
-      end
-    end
+  class ReturnItem < Spree::Base
+    module EligibilityValidator
+      class OrderCompleted < Spree::ReturnItem::EligibilityValidator::BaseValidator
+        def eligible_for_return?
+          if @return_item.inventory_unit.order.completed?
+            return true
+          else
+            add_error(:order_not_completed, Spree.t('return_item_order_not_completed'))
+            return false
+          end
+        end
 
-    def requires_manual_intervention?
-      false
+        def requires_manual_intervention?
+          false
+        end
+      end
     end
   end
 end

data/app/models/spree/return_item/eligibility_validator/rma_required.rb

@@ -1,16 +1,20 @@
 module Spree
-  class ReturnItem::EligibilityValidator::RMARequired < Spree::ReturnItem::EligibilityValidator::BaseValidator
-    def eligible_for_return?
-      if @return_item.return_authorization.present?
-        return true
-      else
-        add_error(:rma_required, Spree.t('return_item_rma_ineligible'))
-        return false
-      end
-    end
+  class ReturnItem < Spree::Base
+    module EligibilityValidator
+      class RMARequired < Spree::ReturnItem::EligibilityValidator::BaseValidator
+        def eligible_for_return?
+          if @return_item.return_authorization.present?
+            return true
+          else
+            add_error(:rma_required, Spree.t('return_item_rma_ineligible'))
+            return false
+          end
+        end
 
-    def requires_manual_intervention?
-      false
+        def requires_manual_intervention?
+          false
+        end
+      end
     end
   end
 end

data/app/models/spree/return_item/eligibility_validator/time_since_purchase.rb

@@ -1,16 +1,20 @@
 module Spree
-  class ReturnItem::EligibilityValidator::TimeSincePurchase < Spree::ReturnItem::EligibilityValidator::BaseValidator
-    def eligible_for_return?
-      if (@return_item.inventory_unit.order.completed_at + Spree::Config[:return_eligibility_number_of_days].days) > Time.current
-        return true
-      else
-        add_error(:number_of_days, Spree.t('return_item_time_period_ineligible'))
-        return false
-      end
-    end
+  class ReturnItem < Spree::Base
+    module EligibilityValidator
+      class TimeSincePurchase < Spree::ReturnItem::EligibilityValidator::BaseValidator
+        def eligible_for_return?
+          if (@return_item.inventory_unit.order.completed_at + Spree::Config[:return_eligibility_number_of_days].days) > Time.current
+            return true
+          else
+            add_error(:number_of_days, Spree.t('return_item_time_period_ineligible'))
+            return false
+          end
+        end
 
-    def requires_manual_intervention?
-      false
+        def requires_manual_intervention?
+          false
+        end
+      end
     end
   end
 end

data/app/models/spree/return_item/exchange_variant_eligibility/same_option_value.rb

@@ -1,41 +1,43 @@
 module Spree
-  module ReturnItem::ExchangeVariantEligibility
-    class SameOptionValue
-      class_attribute :option_type_restrictions
-      self.option_type_restrictions = []
-      # This can be configured in an initializer, e.g.:
-      # Spree::ReturnItem::ExchangeVariantEligibility::SameOptionValue.option_type_restrictions = ["size", "color"]
-      #
-      # This restriction causes only variants that share the same option value for the
-      # specified option types to be returned. e.g.:
-      #
-      # option_type_restrictions = ["color", "waist"]
-      # Variant: blue pants with 32 waist and 30 inseam
-      #
-      # can be exchanged for:
-      # blue pants with 32 waist and 31 inseam
-      #
-      # cannot be exchanged for:
-      # green pants with 32 waist and 30 inseam
-      # blue pants with 34 waist and 32 inseam
+  class ReturnItem < Spree::Base
+    module ExchangeVariantEligibility
+      class SameOptionValue
+        class_attribute :option_type_restrictions
+        self.option_type_restrictions = []
+        # This can be configured in an initializer, e.g.:
+        # Spree::ReturnItem::ExchangeVariantEligibility::SameOptionValue.option_type_restrictions = ["size", "color"]
+        #
+        # This restriction causes only variants that share the same option value for the
+        # specified option types to be returned. e.g.:
+        #
+        # option_type_restrictions = ["color", "waist"]
+        # Variant: blue pants with 32 waist and 30 inseam
+        #
+        # can be exchanged for:
+        # blue pants with 32 waist and 31 inseam
+        #
+        # cannot be exchanged for:
+        # green pants with 32 waist and 30 inseam
+        # blue pants with 34 waist and 32 inseam
 
-      def self.eligible_variants(variant, options = {})
-        product_variants = SameProduct.eligible_variants(variant, options).includes(option_values: :option_type)
-        relevant_option_values = variant.option_values.select { |ov| option_type_restrictions.include? ov.option_type.name }
+        def self.eligible_variants(variant, options = {})
+          product_variants = SameProduct.eligible_variants(variant, options).includes(option_values: :option_type)
+          relevant_option_values = variant.option_values.select { |ov| option_type_restrictions.include? ov.option_type.name }
 
-        if relevant_option_values.present?
-          # Finds all the OptionValueVariants that have any of the
-          # relevant option values, groups by variant and ensures the variant
-          # has ALL of the relevant option values.
-          variant_ids = Spree::OptionValuesVariant.
-            where(variant_id: product_variants.distinct.pluck(:id)).
-            where(option_value: relevant_option_values).
-            group(:variant_id).
-            having('COUNT(*) = ?', relevant_option_values.size).
-            pluck(:variant_id)
-          product_variants.where(id: variant_ids)
-        else
-          product_variants
+          if relevant_option_values.present?
+            # Finds all the OptionValueVariants that have any of the
+            # relevant option values, groups by variant and ensures the variant
+            # has ALL of the relevant option values.
+            variant_ids = Spree::OptionValuesVariant.
+              where(variant_id: product_variants.distinct.pluck(:id)).
+              where(option_value: relevant_option_values).
+              group(:variant_id).
+              having('COUNT(*) = ?', relevant_option_values.size).
+              pluck(:variant_id)
+            product_variants.where(id: variant_ids)
+          else
+            product_variants
+          end
         end
       end
     end

data/app/models/spree/return_item/exchange_variant_eligibility/same_product.rb

@@ -1,8 +1,10 @@
 module Spree
-  module ReturnItem::ExchangeVariantEligibility
-    class SameProduct
-      def self.eligible_variants(variant, stock_locations: nil)
-        Spree::Variant.where(product_id: variant.product_id, is_master: variant.is_master?).in_stock(stock_locations)
+  class ReturnItem < Spree::Base
+    module ExchangeVariantEligibility
+      class SameProduct
+        def self.eligible_variants(variant, stock_locations: nil)
+          Spree::Variant.where(product_id: variant.product_id, is_master: variant.is_master?).in_stock(stock_locations)
+        end
       end
     end
   end

data/app/models/spree/return_item.rb

@@ -93,7 +93,8 @@ module Spree
     end
 
     extend DisplayMoney
-    money_methods :pre_tax_amount, :amount, :total
+    money_methods :pre_tax_amount, :amount, :total, :total_excluding_vat
+    deprecate display_pre_tax_amount: :display_total_excluding_vat, deprecator: Spree::Deprecation
 
     # @return [Boolean] true when this retur item is in a complete reception
     #   state
@@ -159,10 +160,12 @@ module Spree
       amount + additional_tax_total
     end
 
-    # @return [BigDecimal] the cost of the item before tax
-    def pre_tax_amount
+    # @return [BigDecimal] the cost of the item before VAT tax
+    def total_excluding_vat
       amount - included_tax_total
     end
+    alias pre_tax_amount total_excluding_vat
+    deprecate pre_tax_amount: :total_excluding_vat, deprecator: Spree::Deprecation
 
     # @note This uses the exchange_variant_engine configured on the class.
     # @param stock_locations [Array<Spree::StockLocation>] the stock locations to check

data/app/models/spree/shipment.rb

@@ -89,7 +89,12 @@ module Spree
     end
 
     extend DisplayMoney
-    money_methods :cost, :amount, :discounted_cost, :final_price, :item_cost
+    money_methods(
+      :cost, :amount, :discounted_cost, :final_price, :item_cost,
+      :total, :total_before_tax,
+    )
+    deprecate display_discounted_cost: :display_total_before_tax, deprecator: Spree::Deprecation
+    deprecate display_final_price: :display_total, deprecator: Spree::Deprecation
     alias_attribute :amount, :cost
 
     def add_shipping_method(shipping_method, selected = false)
@@ -116,18 +121,40 @@ module Spree
     def discounted_cost
       cost + promo_total
     end
+    deprecate discounted_cost: :total_before_tax, deprecator: Spree::Deprecation
     alias discounted_amount discounted_cost
+    deprecate discounted_amount: :total_before_tax, deprecator: Spree::Deprecation
 
-    def editable_by?(_user)
-      !shipped?
+    # @return [BigDecimal] the amount of this shipment, taking into
+    #   consideration all its adjustments.
+    def total
+      cost + adjustment_total
     end
+    alias final_price total
+    deprecate final_price: :total, deprecator: Spree::Deprecation
 
-    def final_price
-      cost + adjustment_total
+    # @return [BigDecimal] the amount of this item, taking into consideration
+    #   all non-tax adjustments.
+    def total_before_tax
+      amount + adjustments.select { |a| !a.tax? && a.eligible? }.sum(&:amount)
+    end
+
+    # @return [BigDecimal] the amount of this shipment before VAT tax
+    # @note just like `cost`, this does not include any additional tax
+    def total_excluding_vat
+      total_before_tax - included_tax_total
+    end
+    alias pre_tax_amount total_excluding_vat
+    deprecate pre_tax_amount: :total_excluding_vat, deprecator: Spree::Deprecation
+
+    def total_with_items
+      total + item_cost
     end
+    alias final_price_with_items total_with_items
+    deprecate final_price_with_items: :total_with_items, deprecator: Spree::Deprecation
 
-    def final_price_with_items
-      item_cost + final_price
+    def editable_by?(_user)
+      !shipped?
     end
 
     # Decrement the stock counts for all pending inventory units in this
@@ -156,17 +183,13 @@ module Spree
     end
 
     def item_cost
-      line_items.map(&:final_amount).sum
+      line_items.map(&:total).sum
     end
 
     def line_items
       inventory_units.includes(:line_item).map(&:line_item).uniq
     end
 
-    def pre_tax_amount
-      discounted_amount - included_tax_total
-    end
-
     def ready_or_pending?
       ready? || pending?
     end
@@ -297,19 +320,20 @@ module Spree
       if update_attributes params
         if params.key? :selected_shipping_rate_id
           # Changing the selected Shipping Rate won't update the cost (for now)
-          # so we persist the Shipment#cost before running `order.update!`
+          # so we persist the Shipment#cost before running `order.recalculate`
           update_amounts
-          order.update!
+          order.recalculate
         end
 
         true
       end
     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)
+    # Updates the state of the Shipment bypassing any callbacks.
+    #
+    # If this moves the shipmnent to the 'shipped' state, after_ship will be
+    # called.
+    def update_state
       old_state = state
       new_state = determine_state(order)
       if new_state != old_state
@@ -321,38 +345,32 @@ module Spree
       end
     end
 
-    def transfer_to_location(variant, quantity, stock_location)
-      if quantity <= 0
-        raise ArgumentError
+    def update!(order_or_attrs)
+      if order_or_attrs.is_a?(Spree::Order)
+        Spree::Deprecation.warn "Calling Shipment#update! with an order to update the shipments state is deprecated. Please use Shipment#update_state instead."
+        if order_or_attrs.object_id != order.object_id
+          Spree::Deprecation.warn "Additionally, update! is being passed an instance of order which isn't the same object as the shipment's order association"
+        end
+        update_state
+      else
+        super
       end
+    end
 
-      transaction do
-        new_shipment = order.shipments.create!(stock_location: stock_location)
-
-        order.contents.remove(variant, quantity, { shipment: self })
-        order.contents.add(variant, quantity, { shipment: new_shipment })
-
-        refresh_rates
-        new_shipment.refresh_rates
-        save!
-        new_shipment.save!
-      end
+    def transfer_to_location(variant, quantity, stock_location)
+      Spree::Deprecation.warn("Please use the Spree::FulfilmentChanger class instead of Spree::Shipment#transfer_to_location", caller)
+      new_shipment = order.shipments.create!(stock_location: stock_location)
+      transfer_to_shipment(variant, quantity, new_shipment)
     end
 
     def transfer_to_shipment(variant, quantity, shipment_to_transfer_to)
-      if quantity <= 0 || self == shipment_to_transfer_to
-        raise ArgumentError
-      end
-
-      transaction do
-        order.contents.remove(variant, quantity, { shipment: self })
-        order.contents.add(variant, quantity, { shipment: shipment_to_transfer_to })
-
-        refresh_rates
-        save!
-        shipment_to_transfer_to.refresh_rates
-        shipment_to_transfer_to.save!
-      end
+      Spree::Deprecation.warn("Please use the Spree::FulfilmentChanger class instead of Spree::Shipment#transfer_to_location", caller)
+      Spree::FulfilmentChanger.new(
+        current_shipment: self,
+        desired_shipment: shipment_to_transfer_to,
+        variant: variant,
+        quantity: quantity
+      ).run!
     end
 
     def requires_shipment?

data/app/models/spree/shipping_method.rb

@@ -16,7 +16,7 @@ module Spree
     has_many :shipments, through: :shipping_rates
     has_many :cartons, inverse_of: :shipping_method
 
-    has_many :shipping_method_zones
+    has_many :shipping_method_zones, dependent: :destroy
     has_many :zones, through: :shipping_method_zones
 
     belongs_to :tax_category, -> { with_deleted }, class_name: 'Spree::TaxCategory'

data/app/models/spree/shipping_rate.rb

@@ -17,6 +17,8 @@ module Spree
     alias_attribute :amount, :cost
 
     alias_method :discounted_amount, :amount
+    deprecate discounted_amount: :total_before_tax, deprecator: Spree::Deprecation
+    alias_method :total_before_tax, :amount
 
     extend DisplayMoney
     money_methods :amount

data/app/models/spree/shipping_rate_tax.rb

@@ -28,11 +28,7 @@ module Spree
 
     def translation_key
       if tax_rate.included_in_price?
-        if amount > 0
-           :vat
-         else
-           :vat_refund
-         end
+         :vat
        else
          :sales_tax
       end

data/app/models/spree/stock/availability.rb

@@ -0,0 +1,70 @@
+module Spree
+  module Stock
+    # This class manages checking stock availability efficiently for a set of
+    # Variants and StockLocations.
+    #
+    # This serves a similar role to Spree::Stock::Quantifier, but is more
+    # efficient by checking multiple variants at once.
+    class Availability
+      # @param variants [Array<Spree::Variant>] variants to check stock of
+      # @param stock_locations [Array<Spree::StockLocation>] stock_locations to check for stock in
+      def initialize(variants:, stock_locations: Spree::StockLocation.active)
+        @variants = variants
+        @variant_map = variants.index_by(&:id)
+        @stock_locations = stock_locations
+      end
+
+      # Get the on_hand stock quantities
+      # @return [Hash<Integer=>Spree::StockQuantities>] A map of stock_location_ids to the stock quantities available in that location
+      def on_hand_by_stock_location_id
+        counts_on_hand.to_a.group_by do |(_, stock_location_id), _|
+          stock_location_id
+        end.transform_values do |values|
+          Spree::StockQuantities.new(
+            values.map do |(variant_id, _), count|
+              variant = @variant_map[variant_id]
+              count = Float::INFINITY if !variant.should_track_inventory?
+              count = 0 if count < 0
+              [variant, count]
+            end.to_h
+          )
+        end
+      end
+
+      # Get the on_hand stock quantities
+      # @return [Hash<Integer=>Spree::StockQuantities>] A map of stock_location_ids to the stock quantities available in that location
+      def backorderable_by_stock_location_id
+        backorderables.group_by(&:second).transform_values do |variant_ids|
+          Spree::StockQuantities.new(
+            variant_ids.map do |variant_id, _|
+              variant = @variant_map[variant_id]
+              [variant, Float::INFINITY]
+            end.to_h
+          )
+        end
+      end
+
+      private
+
+      def counts_on_hand
+        @counts_on_hand ||=
+          stock_item_scope.
+            group(:variant_id, :stock_location_id).
+            sum(:count_on_hand)
+      end
+
+      def backorderables
+        @backorderables ||=
+          stock_item_scope.
+            where(backorderable: true).
+            pluck(:variant_id, :stock_location_id)
+      end
+
+      def stock_item_scope
+        Spree::StockItem.
+          where(variant_id: @variants).
+          where(stock_location_id: @stock_locations)
+      end
+    end
+  end
+end