solidus_core 1.1.4 → 1.2.0.beta1

data/app/models/spree/prototype.rb

@@ -1,7 +1,11 @@
 module Spree
   class Prototype < Spree::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_many :property_prototypes
+    has_many :properties, through: :property_prototypes
+
+    has_many :option_type_prototypes
+    has_many :option_types, through: :option_type_prototypes
 
     has_many :prototype_taxons, dependent: :destroy
     has_many :taxons, through: :prototype_taxons

data/app/models/spree/reimbursement.rb

@@ -136,6 +136,16 @@ module Spree
       return_items.all?(&:exchange_processed?)
     end
 
+    # Accepts all return items, saves the reimbursement, and performs the reimbursement
+    #
+    # @api public
+    # @return [void]
+    def return_all
+      return_items.each(&:accept!)
+      save!
+      perform!
+    end
+
     private
 
     def generate_number

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

@@ -1,7 +1,7 @@
 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.now
+      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'))

data/app/models/spree/return_reason.rb

@@ -5,14 +5,8 @@ module Spree
     has_many :return_authorizations
 
     def self.reasons_for_return_items(return_items)
-      reasons = Spree::ReturnReason.active
       # Only allow an inactive reason if it's already associated to a return item
-      return_items.each do |return_item|
-        if return_item.return_reason && !return_item.return_reason.active?
-          reasons << return_item.return_reason
-        end
-      end
-      reasons
+      active | return_items.map(&:return_reason).compact
     end
   end
 end

data/app/models/spree/role_user.rb

@@ -4,14 +4,12 @@ module Spree
     belongs_to :role, class_name: "Spree::Role"
     belongs_to :user, class_name: Spree::UserClassHandle.new
 
-    after_save :generate_admin_api_key
+    after_create :auto_generate_spree_api_key
 
     private
 
-    def generate_admin_api_key
-      if role.admin? && user.respond_to?(:spree_api_key) && !user.spree_api_key
-        user.generate_spree_api_key!
-      end
+    def auto_generate_spree_api_key
+      user.try!(:auto_generate_spree_api_key)
     end
   end
 end

data/app/models/spree/shipment.rb

@@ -1,5 +1,3 @@
-require 'ostruct'
-
 module Spree
   class Shipment < Spree::Base
     belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :shipments
@@ -35,6 +33,7 @@ module Spree
     scope :with_state, ->(*s) { where(state: s) }
     # sort by most recent shipped_at, falling back to created_at. add "id desc" to make specs that involve this scope more deterministic.
     scope :reverse_chronological, -> { order('coalesce(spree_shipments.shipped_at, spree_shipments.created_at) desc', id: :desc) }
+    scope :by_store, ->(store) { joins(:order).merge(Spree::Order.by_store(store)) }
 
     # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
     state_machine initial: :pending, use_transactions: false do
@@ -163,10 +162,6 @@ module Spree
       inventory_units.includes(:line_item).map(&:line_item).uniq
     end
 
-    def line_items
-      inventory_units.includes(:line_item).map(&:line_item).uniq
-    end
-
     def ready_or_pending?
       self.ready? || self.pending?
     end
@@ -178,7 +173,7 @@ module Spree
       # StockEstimator.new assigment below will replace the current shipping_method
       original_shipping_method_id = shipping_method.try!(:id)
 
-      new_rates = Stock::Estimator.new(order).shipping_rates(to_package)
+      new_rates = Spree::Config.stock.estimator_class.new(order).shipping_rates(to_package)
 
       # If one of the new rates matches the previously selected shipping
       # method, select that instead of the default provided by the estimator.
@@ -243,7 +238,7 @@ module Spree
 
     def shipped=(value)
       return unless value == '1' && shipped_at.nil?
-      self.shipped_at = Time.now
+      self.shipped_at = Time.current
     end
 
     def shipping_method
@@ -282,7 +277,7 @@ module Spree
         self.update_columns(
           cost: selected_shipping_rate.cost,
           adjustment_total: adjustments.additional.map(&:update!).compact.sum,
-          updated_at: Time.now,
+          updated_at: Time.current,
         )
       end
     end
@@ -304,7 +299,7 @@ module Spree
           # (via Order#paid?) affects the shipment state (YAY)
           self.update_columns(
             state: determine_state(order),
-            updated_at: Time.now
+            updated_at: Time.current
           )
 
           # And then it's time to update shipment states and finally persist
@@ -325,7 +320,7 @@ module Spree
       new_state = determine_state(order)
       update_columns(
         state: new_state,
-        updated_at: Time.now,
+        updated_at: Time.current,
       )
       after_ship if new_state == 'shipped' and old_state != 'shipped'
     end

data/app/models/spree/shipping_method.rb

@@ -4,8 +4,6 @@ module Spree
     include Spree::CalculatedAdjustments
     DISPLAY = [:both, :front_end, :back_end]
 
-    default_scope -> { where(deleted_at: nil) }
-
     has_many :shipping_method_categories, :dependent => :destroy
     has_many :shipping_categories, through: :shipping_method_categories
     has_many :shipping_rates, inverse_of: :shipping_method
@@ -15,7 +13,7 @@ module Spree
     has_many :shipping_method_zones
     has_many :zones, through: :shipping_method_zones
 
-    belongs_to :tax_category, :class_name => 'Spree::TaxCategory'
+    belongs_to :tax_category, -> { with_deleted }, :class_name => 'Spree::TaxCategory'
 
     validates :name, presence: true
 
@@ -42,10 +40,6 @@ 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)

data/app/models/spree/shipping_rate.rb

@@ -1,11 +1,12 @@
 module Spree
   class ShippingRate < Spree::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'
+    belongs_to :shipping_method, -> { with_deleted }, class_name: 'Spree::ShippingMethod', inverse_of: :shipping_rates
+    belongs_to :tax_rate, -> { with_deleted }, class_name: 'Spree::TaxRate'
 
     delegate :order, :currency, to: :shipment
     delegate :name, to: :shipping_method
+    delegate :code, to: :shipping_method, prefix: true
 
     def display_base_price
       Spree::Money.new(cost, currency: currency)
@@ -41,17 +42,5 @@ module Spree
     def display_tax_amount(tax_amount)
       Spree::Money.new(tax_amount, currency: currency)
     end
-
-    def shipping_method
-      Spree::ShippingMethod.unscoped { super }
-    end
-
-    def shipping_method_code
-      shipping_method.code
-    end
-
-    def tax_rate
-      Spree::TaxRate.unscoped { super }
-    end
   end
 end

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

@@ -55,9 +55,8 @@ module Spree
       #
       # Returns an array of Package instances
       def build_packages(packages = Array.new)
-        StockLocation.active.each do |stock_location|
-          units_for_location = unallocated_inventory_units.select { |unit| stock_location.stock_item(unit.variant) }
-          next unless units_for_location.any?
+        stock_location_variant_ids.each do |stock_location, variant_ids|
+          units_for_location = unallocated_inventory_units.select { |unit| variant_ids.include?(unit.variant_id) }
           packer = build_packer(stock_location, units_for_location)
           packages += packer.packages
         end
@@ -66,17 +65,62 @@ module Spree
 
       private
 
+      # This finds the variants we're looking for in each active stock location.
+      # It returns a hash like:
+      #   {
+      #     <stock location> => <set of variant ids>,
+      #     <stock location> => <set of variant ids>,
+      #     ...,
+      #   }
+      # This is done in an awkward way for performance reasons.  It uses two
+      # queries that are kept as performant as possible, and only loads the
+      # minimum required ActiveRecord objects.
+      def stock_location_variant_ids
+        # associate the variant ids we're interested in with stock location ids
+        location_variant_ids = StockItem.
+          where(variant_id: unallocated_variant_ids).
+          joins(:stock_location).
+          merge(StockLocation.active).
+          pluck(:stock_location_id, :variant_id)
+
+        # load activerecord objects for the stock location ids and turn them
+        # into a lookup hash like:
+        #   {
+        #     <stock location id> => <stock location>,
+        #     ...,
+        #   }
+        location_lookup = StockLocation.
+          where(id: location_variant_ids.map(&:first).uniq).
+          map { |l| [l.id, l] }.
+          to_h
+
+        # build the final lookup hash of
+        #   {<stock location> => <set of variant ids>, ...}
+        # using the previous results
+        hash = location_variant_ids.each_with_object({}) do |(location_id, variant_id), hash|
+          location = location_lookup[location_id]
+          hash[location] ||= Set.new
+          hash[location] << variant_id
+        end
+
+        hash
+      end
+
       def unallocated_inventory_units
         inventory_units - @preallocated_inventory_units
       end
 
+      def unallocated_variant_ids
+        unallocated_inventory_units.map(&:variant_id).uniq
+      end
+
       def prioritize_packages(packages)
         prioritizer = Prioritizer.new(inventory_units, packages)
         prioritizer.prioritized_packages
       end
 
       def estimate_packages(packages)
-        estimator = Estimator.new(order)
+        estimator = Spree::Config.stock.estimator_class.new(order)
         packages.each do |package|
           package.shipping_rates = estimator.shipping_rates(package)
         end

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

@@ -20,20 +20,17 @@ module Spree
         rates = calculate_shipping_rates(package)
         rates.select! { |rate| rate.shipping_method.frontend? } if frontend_only
         choose_default_shipping_rate(rates)
-        sort_shipping_rates(rates)
+        Spree::Config.shipping_rate_sorter_class.new(rates).sort
       end
 
       private
       def choose_default_shipping_rate(shipping_rates)
         unless shipping_rates.empty?
-          shipping_rates.min_by(&:cost).selected = true
+          default_shipping_rate = Spree::Config.shipping_rate_selector_class.new(shipping_rates).find_default
+          default_shipping_rate.selected = true
         end
       end
 
-      def sort_shipping_rates(shipping_rates)
-        shipping_rates.sort_by!(&:cost)
-      end
-
       def calculate_shipping_rates(package)
         shipping_methods(package).map do |shipping_method|
           cost = shipping_method.calculator.compute(package)

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

@@ -22,9 +22,10 @@ module Spree
         inventory_units.group_by(&:variant).each do |variant, variant_inventory_units|
           units = variant_inventory_units.clone
           if variant.should_track_inventory?
-            next unless stock_location.stock_item(variant)
+            stock_item = stock_item_for(variant.id)
+            next unless stock_item
 
-            on_hand, backordered = stock_location.fill_status(variant, units.count)
+            on_hand, backordered = stock_item.fill_status(units.count)
             raise Spree::Order::InsufficientStock unless on_hand > 0 || backordered > 0
             package.add_multiple units.slice!(0, on_hand), :on_hand if on_hand > 0
             package.add_multiple units.slice!(0, backordered), :backordered if backordered > 0
@@ -37,6 +38,21 @@ module Spree
       end
 
       private
+
+      def stock_item_for(variant_id)
+        stock_item_lookup[variant_id]
+      end
+
+      # Returns a lookup table in the form of:
+      #   {<variant_id> => <stock_item>, ...}
+      def stock_item_lookup
+        @stock_item_lookup ||= Spree::StockItem.
+          where(variant_id: inventory_units.map(&:variant_id).uniq).
+          where(stock_location_id: stock_location.id).
+          map { |stock_item| [stock_item.variant_id, stock_item] }.
+          to_h # there is only one stock item per variant in a stock location
+      end
+
       def build_splitter
         splitter = nil
         splitters.reverse.each do |klass|

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

@@ -0,0 +1,16 @@
+module Spree
+  module Stock
+    class ShippingRateSelector
+
+      attr_reader :shipping_rates
+
+      def initialize(shipping_rates)
+        @shipping_rates = shipping_rates
+      end
+
+      def find_default
+        shipping_rates.min_by(&:cost)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Spree
+  module Stock
+    class ShippingRateSorter
+
+      attr_reader :shipping_rates
+
+      def initialize(shipping_rates)
+        @shipping_rates = shipping_rates
+      end
+
+      def sort
+        shipping_rates.sort_by(&:cost)
+      end
+    end
+  end
+end

data/app/models/spree/stock_item.rb

@@ -3,15 +3,18 @@ module Spree
     acts_as_paranoid
 
     belongs_to :stock_location, class_name: 'Spree::StockLocation', inverse_of: :stock_items
-    belongs_to :variant, class_name: 'Spree::Variant', inverse_of: :stock_items
+    belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant', inverse_of: :stock_items
     has_many :stock_movements, inverse_of: :stock_item
 
-    validates_presence_of :stock_location, :variant
-    validates_uniqueness_of :variant_id, scope: [:stock_location_id, :deleted_at]
+    validates :stock_location, :variant, presence: true
+    validates :variant_id, uniqueness: { scope: [:stock_location_id, :deleted_at] }, allow_blank: true, unless: :deleted_at
     validates :count_on_hand, numericality: { greater_than_or_equal_to: 0 }, if: :verify_count_on_hand?
 
     delegate :weight, :should_track_inventory?, to: :variant
 
+    # @return [String] the name of this stock item's variant
+    delegate :name, to: :variant, prefix: true
+
     after_save :conditional_variant_touch, if: :changed?
     after_touch { variant.touch }
 
@@ -23,11 +26,6 @@ module Spree
       Spree::InventoryUnit.backordered_for_stock_item(self)
     end
 
-    # @return [String] the name of this stock item's variant
-    def variant_name
-      variant.name
-    end
-
     # Adjusts the count on hand by a given value.
     #
     # @note This will cause backorders to be processed.
@@ -63,13 +61,6 @@ module Spree
       self.in_stock? || self.backorderable?
     end
 
-    # @note This returns the variant regardless of whether it was soft
-    #   deleted.
-    # @return [Spree::Variant] this stock item's variant.
-    def variant
-      Spree::Variant.unscoped { super }
-    end
-
     # Sets the count on hand to zero if it not already zero.
     #
     # @note This processes backorders if the count on hand is not zero.
@@ -77,6 +68,19 @@ module Spree
       self.set_count_on_hand(0) if count_on_hand > 0
     end
 
+    def fill_status(quantity)
+      if count_on_hand >= quantity
+        on_hand = quantity
+        backordered = 0
+      else
+        on_hand = count_on_hand
+        on_hand = 0 if on_hand < 0
+        backordered = backorderable? ? (quantity - on_hand) : 0
+      end
+
+      [on_hand, backordered]
+    end
+
     private
       def verify_count_on_hand?
         count_on_hand_changed? && !backorderable? && (count_on_hand < count_on_hand_was) && (count_on_hand < 0)