solidus_core 2.7.4 → 2.8.0

data/app/models/spree/order_contents.rb

@@ -79,12 +79,8 @@ module Spree
       line_item
     end
 
-    def order_updater
-      @updater ||= Spree::OrderUpdater.new(order)
-    end
-
     def reload_totals
-      order_updater.update
+      @order.recalculate
     end
 
     def add_to_line_item(variant, quantity, options = {})

data/app/models/spree/order_inventory.rb

@@ -60,18 +60,19 @@ module Spree
     end
 
     def add_to_shipment(shipment, quantity)
+      pending_units = []
       if variant.should_track_inventory?
         on_hand, back_order = shipment.stock_location.fill_status(variant, quantity)
 
-        on_hand.times { shipment.set_up_inventory('on_hand', variant, order, line_item) }
-        back_order.times { shipment.set_up_inventory('backordered', variant, order, line_item) }
+        on_hand.times { pending_units << shipment.set_up_inventory('on_hand', variant, order, line_item) }
+        back_order.times { pending_units << shipment.set_up_inventory('backordered', variant, order, line_item) }
       else
-        quantity.times { shipment.set_up_inventory('on_hand', variant, order, line_item) }
+        quantity.times { pending_units << shipment.set_up_inventory('on_hand', variant, order, line_item) }
       end
 
       # adding to this shipment, and removing from stock_location
       if order.completed?
-        shipment.stock_location.unstock(variant, quantity, shipment)
+        Spree::Stock::InventoryUnitsFinalizer.new(pending_units).run!
       end
 
       quantity

data/app/models/spree/product.rb

@@ -297,6 +297,7 @@ module Spree
     # variants. If all else fails, will return a new image object.
     # @return [Spree::Image] the image to display
     def display_image
+      Spree::Deprecation.warn('Spree::Product#display_image is DEPRECATED. Choose an image from Spree::Product#gallery instead.')
       images.first || variant_images.first || Spree::Image.new
     end
 
@@ -310,6 +311,14 @@ module Spree
       end
     end
 
+    # The gallery for the product, which represents all the images
+    # associated with it, including those on its variants
+    #
+    # @return [Spree::Gallery] the media for a variant
+    def gallery
+      @gallery ||= Spree::Config.product_gallery_class.new(self)
+    end
+
     private
 
     def any_variants_not_track_inventory?

data/app/models/spree/product/scopes.rb

@@ -63,10 +63,9 @@ module Spree
     #
     #   SELECT COUNT(*) ...
     add_search_scope :in_taxon do |taxon|
-      includes(:classifications)
-        .where('spree_products_taxons.taxon_id' => taxon.self_and_descendants.pluck(:id))
-        .select(Spree::Classification.arel_table[:position])
-        .order(Spree::Classification.arel_table[:position].asc)
+      includes(:classifications).
+      where("spree_products_taxons.taxon_id" => taxon.self_and_descendants.pluck(:id)).
+      order(Spree::Classification.arel_table[:position].asc)
     end
 
     # This scope selects products in all taxons AND all its descendants

data/app/models/spree/promotion.rb

@@ -36,7 +36,7 @@ module Spree
 
     before_save :normalize_blank_values
 
-    scope :coupons, -> { where.not(code: nil) }
+    scope :coupons, -> { joins(:codes).distinct }
     scope :advertised, -> { where(advertise: true) }
     scope :active, -> do
       table = arel_table
@@ -49,11 +49,6 @@ module Spree
     self.whitelisted_ransackable_associations = ['codes']
     self.whitelisted_ransackable_attributes = ['path', 'promotion_category_id']
 
-    # temporary code. remove after the column is dropped from the db.
-    def columns
-      super.reject { |column| column.name == "code" }
-    end
-
     def self.order_activatable?(order)
       order && !UNACTIVATABLE_ORDER_STATES.include?(order.state)
     end

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

@@ -25,6 +25,20 @@ module Spree
         self
       end
 
+      def remove
+        if promotion.blank?
+          set_error_code :coupon_code_not_found
+        elsif !promotion_exists_on_order?(order, promotion)
+          set_error_code :coupon_code_not_present
+        else
+          promotion.remove_from(order)
+          order.recalculate
+          set_success_code :coupon_code_removed
+        end
+
+        self
+      end
+
       def set_success_code(status_code)
         @status_code = status_code
         @success = I18n.t(status_code, scope: 'spree')
@@ -56,6 +70,7 @@ module Spree
       def handle_present_promotion(promotion)
         return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded? || promotion_code.usage_limit_exceeded?
         return promotion_applied if promotion_exists_on_order?(order, promotion)
+
         unless promotion.eligible?(order, promotion_code: promotion_code)
           self.error = promotion.eligibility_errors.full_messages.first unless promotion.eligibility_errors.blank?
           return (error || ineligible_for_this_order)

data/app/models/spree/reimbursement.rb

@@ -18,6 +18,7 @@ module Spree
     accepts_nested_attributes_for :return_items, allow_destroy: true
 
     before_create :generate_number
+    before_create :calculate_total
 
     scope :reimbursed, -> { where(reimbursement_status: 'reimbursed') }
 
@@ -98,12 +99,15 @@ module Spree
       total - paid_amount
     end
 
-    def perform!
+    def perform!(created_by: nil)
+      unless created_by
+        Spree::Deprecation.warn("Calling #perform on #{self} without created_by is deprecated")
+      end
       reimbursement_tax_calculator.call(self)
       reload
       update!(total: calculated_total)
 
-      reimbursement_performer.perform(self)
+      reimbursement_performer.perform(self, created_by: created_by)
 
       if unpaid_amount_within_tolerance?
         reimbursed!
@@ -116,12 +120,15 @@ module Spree
       end
     end
 
-    def simulate
+    def simulate(created_by: nil)
+      unless created_by
+        Spree::Deprecation.warn("Calling #simulate on #{self} without created_by is deprecated")
+      end
       reimbursement_simulator_tax_calculator.call(self)
       reload
       update!(total: calculated_total)
 
-      reimbursement_performer.simulate(self)
+      reimbursement_performer.simulate(self, created_by: created_by)
     end
 
     def return_items_requiring_exchange
@@ -139,15 +146,23 @@ module Spree
     # Accepts all return items, saves the reimbursement, and performs the reimbursement
     #
     # @api public
+    # @param [Spree.user_class] created_by the user that is performing this action
     # @return [void]
-    def return_all
+    def return_all(created_by: nil)
+      unless created_by
+        Spree::Deprecation.warn("Calling #return_all on #{self} without created_by is deprecated")
+      end
       return_items.each(&:accept!)
       save!
-      perform!
+      perform!(created_by: created_by)
     end
 
     private
 
+    def calculate_total
+      self.total ||= calculated_total
+    end
+
     def generate_number
       self.number ||= loop do
         random = "RI#{Array.new(9){ rand(9) }.join}"

data/app/models/spree/reimbursement_performer.rb

@@ -11,22 +11,28 @@ module Spree
       # - #description
       # - #display_amount
       # so they can be displayed in the Admin UI appropriately.
-      def simulate(reimbursement)
-        execute(reimbursement, true)
+      def simulate(reimbursement, created_by: nil)
+        unless created_by
+          Spree::Deprecation.warn("Calling #simulate on #{self} without created_by is deprecated")
+        end
+        execute(reimbursement, true, created_by: created_by)
       end
 
       # Actually perform the reimbursement
-      def perform(reimbursement)
-        execute(reimbursement, false)
+      def perform(reimbursement, created_by: nil)
+        unless created_by
+          Spree::Deprecation.warn("Calling #perform on #{self} without created_by is deprecated")
+        end
+        execute(reimbursement, false, created_by: created_by)
       end
 
       private
 
-      def execute(reimbursement, simulate)
+      def execute(reimbursement, simulate, created_by:)
         reimbursement_type_hash = calculate_reimbursement_types(reimbursement)
 
         reimbursement_type_hash.flat_map do |reimbursement_type, return_items|
-          reimbursement_type.reimburse(reimbursement, return_items, simulate)
+          reimbursement_type.reimburse(reimbursement, return_items, simulate, created_by: created_by)
         end
       end
 

data/app/models/spree/reimbursement_type.rb

@@ -11,7 +11,7 @@ module Spree
     # This method will reimburse the return items based on however it child implements it
     # By default it takes a reimbursement, the return items it needs to reimburse, and if
     # it is a simulation or a real reimbursement. This should return an array
-    def self.reimburse(_reimbursement, _return_items, _simulate)
+    def self.reimburse(_reimbursement, _return_items, _simulate, *_optional_args)
       raise "Implement me"
     end
   end

data/app/models/spree/reimbursement_type/credit.rb

@@ -5,9 +5,12 @@ module Spree
     extend Spree::ReimbursementType::ReimbursementHelpers
 
     class << self
-      def reimburse(reimbursement, return_items, simulate)
+      def reimburse(reimbursement, return_items, simulate, created_by: nil)
+        unless created_by
+          Spree::Deprecation.warn("Calling #reimburse on #{self} without created_by is deprecated")
+        end
         unpaid_amount = return_items.sum(&:total).round(2, :down)
-        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate)
+        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate, created_by: created_by)
         reimbursement_list
       end
     end

data/app/models/spree/reimbursement_type/exchange.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Spree::ReimbursementType::Exchange < Spree::ReimbursementType
-  def self.reimburse(reimbursement, return_items, simulate)
+  def self.reimburse(reimbursement, return_items, simulate, *_optional_args)
     return [] unless return_items.present?
 
     exchange = Spree::Exchange.new(reimbursement.order, return_items)

data/app/models/spree/reimbursement_type/original_payment.rb

@@ -4,7 +4,7 @@ class Spree::ReimbursementType::OriginalPayment < Spree::ReimbursementType
   extend Spree::ReimbursementType::ReimbursementHelpers
 
   class << self
-    def reimburse(reimbursement, return_items, simulate)
+    def reimburse(reimbursement, return_items, simulate, _created_by)
       unpaid_amount = return_items.sum(&:total).round(2, :down)
       payments = reimbursement.order.payments.completed
 

data/app/models/spree/reimbursement_type/reimbursement_helpers.rb

@@ -20,8 +20,8 @@ module Spree
       [reimbursement_list, unpaid_amount]
     end
 
-    def create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list = [])
-      credits = [create_credit(reimbursement, unpaid_amount, simulate)]
+    def create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list = [], created_by:)
+      credits = [create_credit(reimbursement, unpaid_amount, simulate, created_by: created_by)]
       unpaid_amount -= credits.sum(&:amount)
       reimbursement_list += credits
 
@@ -43,19 +43,19 @@ module Spree
 
     # If you have multiple methods of crediting a customer, overwrite this method
     # Must return an array of objects the respond to #description, #display_amount
-    def create_credit(reimbursement, unpaid_amount, simulate)
-      creditable = create_creditable(reimbursement, unpaid_amount)
+    def create_credit(reimbursement, unpaid_amount, simulate, created_by:)
+      creditable = create_creditable(reimbursement, unpaid_amount, created_by: created_by)
       credit = reimbursement.credits.build(creditable: creditable, amount: unpaid_amount)
       simulate ? credit.readonly! : credit.save!
       credit
     end
 
-    def create_creditable(reimbursement, unpaid_amount)
+    def create_creditable(reimbursement, unpaid_amount, created_by:)
       Spree::Reimbursement::Credit.default_creditable_class.new(
         user: reimbursement.order.user,
         amount: unpaid_amount,
         category: Spree::StoreCreditCategory.reimbursement_category(reimbursement),
-        created_by: Spree::StoreCredit.default_created_by,
+        created_by: created_by,
         memo: "Refund for uncreditable payments on order #{reimbursement.order.number}",
         currency: reimbursement.order.currency
       )

data/app/models/spree/reimbursement_type/store_credit.rb

@@ -4,17 +4,32 @@ class Spree::ReimbursementType::StoreCredit < Spree::ReimbursementType
   extend Spree::ReimbursementType::ReimbursementHelpers
 
   class << self
-    def reimburse(reimbursement, return_items, simulate)
+    def reimburse(reimbursement, return_items, simulate, created_by: nil)
+      unless created_by
+        Spree::Deprecation.warn("Calling #reimburse on #{self} without created_by is deprecated")
+      end
       unpaid_amount = return_items.sum(&:total).to_d.round(2, :down)
       payments = store_credit_payments(reimbursement)
       reimbursement_list = []
 
       # Credit each store credit that was used on the order
-      reimbursement_list, unpaid_amount = create_refunds(reimbursement, payments, unpaid_amount, simulate, reimbursement_list)
+      reimbursement_list, unpaid_amount = create_refunds(
+        reimbursement,
+        payments,
+        unpaid_amount,
+        simulate,
+        reimbursement_list
+      )
 
       # If there is any amount left to pay out to the customer, then create credit with that amount
       if unpaid_amount > 0.0
-        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list)
+        reimbursement_list, _unpaid_amount = create_credits(
+          reimbursement,
+          unpaid_amount,
+          simulate,
+          reimbursement_list,
+          created_by: created_by
+        )
       end
 
       reimbursement_list

data/app/models/spree/shipment.rb

@@ -13,6 +13,7 @@ module Spree
     has_many :shipping_methods, through: :shipping_rates
     has_many :state_changes, as: :stateful
     has_many :cartons, -> { distinct }, through: :inventory_units
+    has_many :line_items, -> { distinct }, through: :inventory_units
 
     before_validation :set_cost_zero_when_nil
 
@@ -32,7 +33,10 @@ module Spree
     scope :trackable, -> { where("tracking IS NOT NULL AND tracking != ''") }
     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 :reverse_chronological, -> {
+      order(Arel.sql("coalesce(#{Spree::Shipment.table_name}.shipped_at, #{Spree::Shipment.table_name}.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)
@@ -164,12 +168,7 @@ module Spree
     # Any previous non-pending inventory units are skipped as their stock had
     # already been allocated.
     def finalize!
-      transaction do
-        pending_units = inventory_units.select(&:pending?)
-        pending_manifest = Spree::ShippingManifest.new(inventory_units: pending_units)
-        pending_manifest.items.each { |item| manifest_unstock(item) }
-        Spree::InventoryUnit.finalize_units!(pending_units)
-      end
+      finalize_pending_inventory_units
     end
 
     def include?(variant)
@@ -188,10 +187,6 @@ module Spree
       line_items.map(&:total).sum
     end
 
-    def line_items
-      inventory_units.includes(:line_item).map(&:line_item).uniq
-    end
-
     def ready_or_pending?
       ready? || pending?
     end
@@ -398,6 +393,11 @@ module Spree
 
     private
 
+    def finalize_pending_inventory_units
+      pending_units = inventory_units.select(&:pending?)
+      Spree::Stock::InventoryUnitsFinalizer.new(pending_units).run!
+    end
+
     def after_ship
       order.shipping.ship_shipment(self, suppress_mailer: suppress_mailer)
     end

data/app/models/spree/stock/allocator/base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    module Allocator
+      class Base
+        attr_reader :availability
+
+        def initialize(availability)
+          @availability = availability
+        end
+
+        def allocate_inventory(_desired)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/app/models/spree/stock/allocator/on_hand_first.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    module Allocator
+      class OnHandFirst < Spree::Stock::Allocator::Base
+        def allocate_inventory(desired)
+          # Allocate any available on hand inventory
+          on_hand = allocate_on_hand(desired)
+          desired -= on_hand.values.sum if on_hand.present?
+
+          # Allocate remaining desired inventory from backorders
+          backordered = allocate_backordered(desired)
+          desired -= backordered.values.sum if backordered.present?
+
+          # If all works at this point desired must be empty
+          [on_hand, backordered, desired]
+        end
+
+        protected
+
+        def allocate_on_hand(desired)
+          allocate(availability.on_hand_by_stock_location_id, desired)
+        end
+
+        def allocate_backordered(desired)
+          allocate(availability.backorderable_by_stock_location_id, desired)
+        end
+
+        def allocate(availability_by_location, desired)
+          availability_by_location.transform_values do |available|
+            # Find the desired inventory which is available at this location
+            packaged = available & desired
+            # Remove found inventory from desired
+            desired -= packaged
+            packaged
+          end
+        end
+      end
+    end
+  end
+end