solidus_core 4.5.1 → 4.6.0

data/app/models/spree/order_shipping.rb

@@ -56,6 +56,7 @@ class Spree::OrderShipping
         inventory_units:,
         shipped_at:,
         external_number:,
+        suppress_email: suppress_mailer,
         tracking: tracking_number
       )
     end
@@ -68,18 +69,10 @@ class Spree::OrderShipping
       end
     end
 
-    send_shipment_emails(carton) if stock_location.fulfillable? && !suppress_mailer # e.g. digital gift cards that aren't actually shipped
     @order.shipments.reload
     @order.recalculate
 
+    Spree::Bus.publish(:carton_shipped, carton:)
     carton
   end
-
-  private
-
-  def send_shipment_emails(carton)
-    carton.orders.each do |order|
-      Spree::Config.carton_shipped_email_class.shipped_email(order:, carton:).deliver_later
-    end
-  end
 end

data/app/models/spree/order_taxation.rb

@@ -57,7 +57,7 @@ module Spree
 
       # Remove any tax adjustments tied to rates which no longer match.
       unmatched_adjustments = tax_adjustments - active_adjustments
-      item.adjustments.destroy(unmatched_adjustments)
+      unmatched_adjustments.each(&:mark_for_destruction)
     end
 
     # Update or create a new tax adjustment on an item.
@@ -77,7 +77,8 @@ module Spree
         label: tax_item.label,
         included: tax_item.included_in_price
       )
-      tax_adjustment.update!(amount: tax_item.amount)
+
+      tax_adjustment.amount = tax_item.amount
       tax_adjustment
     end
   end

data/app/models/spree/order_updater.rb

@@ -157,9 +157,12 @@ module Spree
       recalculate_adjustments
 
       all_items = line_items + shipments
-      order_tax_adjustments = adjustments.select(&:tax?)
+      # Ignore any adjustments that have been marked for destruction in our
+      # calculations. They'll get removed when/if we persist the order.
+      valid_adjustments = adjustments.reject(&:marked_for_destruction?)
+      order_tax_adjustments = valid_adjustments.select(&:tax?)
 
-      order.adjustment_total = all_items.sum(&:adjustment_total) + adjustments.sum(&:amount)
+      order.adjustment_total = all_items.sum(&:adjustment_total) + valid_adjustments.sum(&:amount)
       order.included_tax_total = all_items.sum(&:included_tax_total) + order_tax_adjustments.select(&:included?).sum(&:amount)
       order.additional_tax_total = all_items.sum(&:additional_tax_total) + order_tax_adjustments.reject(&:included?).sum(&:amount)
 
@@ -185,11 +188,12 @@ module Spree
       yield
       new_state = order.public_send(state)
       if old_state != new_state
-        order.state_changes.new(
-          previous_state: old_state,
-          next_state:     new_state,
-          name:,
-          user_id:        order.user_id
+        StateChangeTrackingJob.perform_later(
+          order,
+          old_state,
+          new_state,
+          Time.current,
+          name
         )
       end
     end

data/app/models/spree/payment_method.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'spree/preferences/persistable'
 require 'spree/preferences/statically_configurable'
 
 module Spree

data/app/models/spree/product.rb

@@ -23,7 +23,7 @@ module Spree
 
     has_many :product_properties, dependent: :destroy, inverse_of: :product
     has_many :properties, through: :product_properties
-    has_many :variant_property_rules
+    has_many :variant_property_rules, dependent: :destroy
     has_many :variant_property_rule_values, through: :variant_property_rules, source: :values
     has_many :variant_property_rule_conditions, through: :variant_property_rules, source: :conditions
 
@@ -31,19 +31,21 @@ module Spree
     has_many :taxons, through: :classifications, before_remove: :remove_taxon
 
     belongs_to :tax_category, class_name: 'Spree::TaxCategory', optional: true
-    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :products, optional: true
+    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :products
     belongs_to :primary_taxon, class_name: 'Spree::Taxon', optional: true
 
     has_one :master,
       -> { where(is_master: true).with_discarded },
       inverse_of: :product,
       class_name: 'Spree::Variant',
-      autosave: true
+      autosave: true,
+      dependent: false
 
     has_many :variants,
       -> { where(is_master: false).order(:position) },
       inverse_of: :product,
-      class_name: 'Spree::Variant'
+      class_name: 'Spree::Variant',
+      dependent: false
 
     has_many :variants_including_master,
       -> { order(:position) },
@@ -122,7 +124,6 @@ module Spree
     validates :meta_title, length: { maximum: 255 }
     validates :name, presence: true
     validates :price, presence: true, if: proc { Spree::Config[:require_master_price] }
-    validates :shipping_category_id, presence: true
     validates :slug, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
 
     attr_accessor :option_values_hash

data/app/models/spree/product_option_type.rb

@@ -2,8 +2,8 @@
 
 module Spree
   class ProductOptionType < Spree::Base
-    belongs_to :product, class_name: 'Spree::Product', inverse_of: :product_option_types, touch: true, optional: true
-    belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :product_option_types, optional: true
+    belongs_to :product, class_name: 'Spree::Product', inverse_of: :product_option_types, touch: true
+    belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :product_option_types
     acts_as_list scope: :product
   end
 end

data/app/models/spree/product_property.rb

@@ -6,8 +6,8 @@ module Spree
 
     acts_as_list scope: :product
 
-    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties, optional: true
-    belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties, optional: true
+    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties
+    belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties
 
     self.allowed_ransackable_attributes = ['value']
   end

data/app/models/spree/role_user.rb

@@ -3,12 +3,12 @@
 module Spree
   class RoleUser < Spree::Base
     self.table_name = "spree_roles_users"
-    belongs_to :role, class_name: "Spree::Role", optional: true
-    belongs_to :user, class_name: Spree::UserClassHandle.new, optional: true
+    belongs_to :role, class_name: "Spree::Role"
+    belongs_to :user, class_name: Spree::UserClassHandle.new
 
     after_create :auto_generate_spree_api_key
 
-    validates_uniqueness_of :role_id, scope: :user_id
+    validates :role_id, uniqueness: { scope: :user_id }
 
     private
 

data/app/models/spree/shipment.rb

@@ -200,15 +200,11 @@ module Spree
       end
     end
 
-    # Determines the appropriate +state+ according to the following logic:
-    #
-    # canceled   if order is canceled
-    # pending    unless order is complete and +order.payment_state+ is +paid+
-    # shipped    if already shipped (ie. does not change the state)
-    # ready      all other cases
     def determine_state(order)
-      return 'canceled' if order.canceled?
+      Spree.deprecator.warn "Use Spree::Shipment#recalculate_state instead"
+
       return 'shipped' if shipped?
+      return 'canceled' if order.canceled? || inventory_units.all?(&:canceled?)
       return 'pending' unless order.can_ship?
       if can_transition_from_pending_to_ready?
         'ready'
@@ -217,6 +213,27 @@ module Spree
       end
     end
 
+    # Assigns the appropriate +state+ according to the following logic:
+    #
+    # canceled   if order is canceled
+    # pending    unless order is complete and +order.payment_state+ is +paid+
+    # shipped    if already shipped (ie. does not change the state)
+    # ready      all other cases
+    def recalculate_state
+      self.state =
+        if shipped?
+          "shipped"
+        elsif order.canceled? || inventory_units.all?(&:canceled?)
+          "canceled"
+        elsif !order.can_ship?
+          "pending"
+        elsif can_transition_from_pending_to_ready?
+          "ready"
+        else
+          "pending"
+        end
+    end
+
     def set_up_inventory(state, variant, _order, line_item)
       inventory_units.create(
         state:,
@@ -292,12 +309,9 @@ module Spree
     # called.
     def update_state
       old_state = state
-      new_state = determine_state(order)
+      new_state = recalculate_state
       if new_state != old_state
-        update_columns(
-          state: new_state,
-          updated_at: Time.current
-        )
+        update_columns state: new_state, updated_at: Time.current
         after_ship if new_state == 'shipped'
       end
     end

data/app/models/spree/shipping_category.rb

@@ -5,8 +5,8 @@ module Spree
     self.allowed_ransackable_attributes = %w[name]
 
     validates :name, presence: true
-    has_many :products, inverse_of: :shipping_category
-    has_many :shipping_method_categories, inverse_of: :shipping_category
+    has_many :products, inverse_of: :shipping_category, dependent: :restrict_with_error
+    has_many :shipping_method_categories, inverse_of: :shipping_category, dependent: :destroy
     has_many :shipping_methods, through: :shipping_method_categories
   end
 end

data/app/models/spree/shipping_method_category.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class ShippingMethodCategory < Spree::Base
-    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod', optional: true
-    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :shipping_method_categories, optional: true
+    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod'
+    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :shipping_method_categories
   end
 end

data/app/models/spree/state.rb

@@ -2,10 +2,10 @@
 
 module Spree
   class State < Spree::Base
-    belongs_to :country, class_name: 'Spree::Country', optional: true
-    has_many :addresses, dependent: :nullify
+    belongs_to :country, class_name: 'Spree::Country'
+    has_many :addresses, dependent: :nullify, inverse_of: :state
 
-    validates :country, :name, presence: true
+    validates :name, presence: true
 
     scope :with_name_or_abbr, ->(name_or_abbr) do
       where(
@@ -15,6 +15,7 @@ module Spree
       )
     end
 
+    self.allowed_ransackable_associations = %w[country]
     self.allowed_ransackable_attributes = %w[name]
 
     # table of { country.id => [ state.id , state.name ] }, arrays sorted by name
@@ -36,7 +37,9 @@ module Spree
     end
 
     def state_with_country
-      "#{name} (#{country})"
+      Rails.cache.fetch("#{cache_key_with_version}/state_with_country") do
+        "#{name} (#{country})"
+      end
     end
   end
 end

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

@@ -11,14 +11,8 @@ module Spree
       #        If unspecified it will check inventory in all available StockLocations
       def initialize(variant, stock_location_or_id = nil)
         @variant = variant
-        @stock_items = variant.stock_items.select do |stock_item|
-          if stock_location_or_id
-            stock_item.stock_location == stock_location_or_id ||
-              stock_item.stock_location_id == stock_location_or_id
-          else
-            stock_item.stock_location.active?
-          end
-        end
+        @stock_location_or_id = stock_location_or_id
+        @stock_items = variant_stock_items
       end
 
       # Returns the total number of inventory units on hand for the variant.
@@ -26,7 +20,7 @@ module Spree
       # @return [Fixnum] number of inventory units on hand, or infinity if
       #   inventory is not tracked on the variant.
       def total_on_hand
-        if @variant.should_track_inventory?
+        if variant.should_track_inventory?
           stock_items.sum(&:count_on_hand)
         else
           Float::INFINITY
@@ -48,6 +42,36 @@ module Spree
       def can_supply?(required)
         total_on_hand >= required || backorderable?
       end
+
+      def positive_stock
+        return unless stock_location
+
+        on_hand = stock_location.count_on_hand(variant)
+        on_hand.positive? ? on_hand : 0
+      end
+
+      private
+
+      attr_reader :variant, :stock_location_or_id
+
+      def stock_location
+        @stock_location ||= if stock_location_or_id.is_a?(Spree::StockLocation)
+          stock_location_or_id
+        else
+          Spree::StockLocation.find_by(id: stock_location_or_id)
+        end
+      end
+
+      def variant_stock_items
+        variant.stock_items.select do |stock_item|
+          if stock_location_or_id
+            stock_item.stock_location == stock_location_or_id ||
+              stock_item.stock_location_id == stock_location_or_id
+          else
+            stock_item.stock_location.active?
+          end
+        end
+      end
     end
   end
 end

data/app/models/spree/stock_item.rb

@@ -106,7 +106,7 @@ module Spree
     def should_touch_variant?
       # the variant_id changes from nil when a new stock location is added
       inventory_cache_threshold &&
-        (saved_change_to_count_on_hand&.any? { |cache| cache < inventory_cache_threshold }) ||
+        saved_change_to_count_on_hand&.any? { |cache| cache < inventory_cache_threshold } ||
         saved_change_to_variant_id?
     end
 

data/app/models/spree/stock_location.rb

@@ -15,6 +15,7 @@ module Spree
     has_many :stock_movements, through: :stock_items
     has_many :user_stock_locations, dependent: :delete_all
     has_many :users, through: :user_stock_locations
+    has_many :customer_returns, inverse_of: :stock_location, dependent: :restrict_with_error
 
     belongs_to :state, class_name: 'Spree::State', optional: true
     belongs_to :country, class_name: 'Spree::Country', optional: true
@@ -22,8 +23,8 @@ module Spree
     has_many :shipping_method_stock_locations, dependent: :destroy
     has_many :shipping_methods, through: :shipping_method_stock_locations
 
-    validates_presence_of :name
-    validates_uniqueness_of :code, allow_blank: true, case_sensitive: false
+    validates :name, presence: true
+    validates :code, uniqueness: { allow_blank: true, case_sensitive: false }
 
     scope :active, -> { where(active: true) }
     scope :order_default, -> { order(default: :desc, position: :asc) }

data/app/models/spree/store.rb

@@ -27,6 +27,12 @@ module Spree
     before_save :ensure_default_exists_and_is_unique
     before_destroy :validate_not_default
 
+    enum :reverse_charge_status, {
+      disabled: 0,
+      enabled: 1,
+      not_validated: 2
+    }, prefix: true
+
     def available_locales
       locales = super()
       if locales

data/app/models/spree/store_credit.rb

@@ -18,9 +18,9 @@ class Spree::StoreCredit < Spree::PaymentSource
   belongs_to :credit_type, class_name: 'Spree::StoreCreditType', foreign_key: 'type_id', optional: true
   has_many :store_credit_events
 
-  validates_presence_of :user_id, :category_id, :type_id, :created_by_id, :currency
-  validates_numericality_of :amount, { greater_than: 0 }
-  validates_numericality_of :amount_used, { greater_than_or_equal_to: 0 }
+  validates :user_id, :category_id, :type_id, :created_by_id, :currency, presence: true
+  validates :amount, numericality: { greater_than: 0 }
+  validates :amount_used, numericality: { greater_than_or_equal_to: 0 }
   validate :amount_used_less_than_or_equal_to_amount
   validate :amount_authorized_less_than_or_equal_to_amount
 

data/app/models/spree/store_credit_event.rb

@@ -9,7 +9,7 @@ module Spree
     belongs_to :originator, polymorphic: true, optional: true
     belongs_to :store_credit_reason, class_name: 'Spree::StoreCreditReason', inverse_of: :store_credit_events, optional: true
 
-    validates_presence_of :store_credit_reason, if: :action_requires_reason?
+    validates :store_credit_reason, presence: { if: :action_requires_reason? }
 
     NON_EXPOSED_ACTIONS = [Spree::StoreCredit::ELIGIBLE_ACTION, Spree::StoreCredit::AUTHORIZE_ACTION]
 

data/app/models/spree/tax_category.rb

@@ -11,7 +11,7 @@ module Spree
     end
 
     validates :name, presence: true
-    validates_uniqueness_of :name, case_sensitive: true, unless: :deleted_at
+    validates :name, uniqueness: { case_sensitive: true, unless: :deleted_at }
 
     has_many :tax_rate_tax_categories,
       class_name: 'Spree::TaxRateTaxCategory',

data/app/models/spree/taxon.rb

@@ -13,9 +13,6 @@ module Spree
     has_many :classifications, -> { order(:position) }, dependent: :delete_all, inverse_of: :taxon
     has_many :products, through: :classifications
 
-    has_many :promotion_rule_taxons
-    has_many :promotion_rules, through: :promotion_rule_taxons
-
     before_save :set_permalink
     after_update :update_child_permalinks, if: :saved_change_to_permalink?
 

data/app/models/spree/taxonomy.rb

@@ -7,8 +7,8 @@ module Spree
     validates :name, presence: true
     validates :name, uniqueness: true
 
-    has_many :taxons, inverse_of: :taxonomy
-    has_one :root, -> { where parent_id: nil }, class_name: "Spree::Taxon", dependent: :destroy
+    has_many :taxons, inverse_of: :taxonomy, dependent: false
+    has_one :root, -> { where parent_id: nil }, class_name: "Spree::Taxon", dependent: :destroy, inverse_of: false
 
     after_save :set_name
 

data/app/models/spree/user_address.rb

@@ -2,11 +2,11 @@
 
 module Spree
   class UserAddress < Spree::Base
-    belongs_to :user, class_name: UserClassHandle.new, foreign_key: "user_id", optional: true
-    belongs_to :address, class_name: "Spree::Address", optional: true
+    belongs_to :user, class_name: UserClassHandle.new, foreign_key: "user_id", inverse_of: :user_addresses
+    belongs_to :address, class_name: "Spree::Address"
 
-    validates_uniqueness_of :address_id, scope: :user_id
-    validates_uniqueness_of :user_id, conditions: -> { default_shipping }, message: :default_address_exists, if: :default?
+    validates :address_id, uniqueness: { scope: :user_id }
+    validates :user_id, uniqueness: { conditions: -> { default_shipping }, message: :default_address_exists, if: :default? }
 
     scope :with_address_values, ->(address_attributes) do
       joins(:address).merge(

data/app/models/spree/variant.rb

@@ -74,7 +74,7 @@ module Spree
 
     validates :cost_price, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
     validates :price,      numericality: { greater_than_or_equal_to: 0, allow_nil: true }
-    validates_uniqueness_of :sku, allow_blank: true, case_sensitive: true, conditions: -> { where(deleted_at: nil) }, if: :enforce_unique_sku?
+    validates :sku, uniqueness: { allow_blank: true, case_sensitive: true, conditions: -> { where(deleted_at: nil) }, if: :enforce_unique_sku? }
 
     after_create :create_stock_items
     after_create :set_master_out_of_stock, unless: :is_master?

data/app/models/spree/variant_property_rule.rb

@@ -13,7 +13,7 @@
 # targeted by the rule, the properties will automatically apply to the variant.
 module Spree
   class VariantPropertyRule < Spree::Base
-    belongs_to :product, touch: true, optional: true
+    belongs_to :product, touch: true
 
     has_many :values, class_name: 'Spree::VariantPropertyRuleValue', dependent: :destroy
     has_many :properties, through: :values

data/app/models/spree/variant_property_rule_condition.rb

@@ -5,6 +5,6 @@ module Spree
     belongs_to :option_value, optional: true
     belongs_to :variant_property_rule, touch: true, optional: true
 
-    validates_uniqueness_of :option_value_id, scope: :variant_property_rule_id
+    validates :option_value_id, uniqueness: { scope: :variant_property_rule_id }
   end
 end

data/app/models/spree/wallet_payment_source.rb

@@ -5,8 +5,8 @@ module Spree
     belongs_to :user, class_name: Spree::UserClassHandle.new, foreign_key: 'user_id', inverse_of: :wallet_payment_sources, optional: true
     belongs_to :payment_source, polymorphic: true, inverse_of: :wallet_payment_sources, optional: true
 
-    validates_presence_of :user
-    validates_presence_of :payment_source
+    validates :user, presence: true
+    validates :payment_source, presence: true
     validates :user_id, uniqueness: {
       scope: [:payment_source_type, :payment_source_id],
       message: :payment_source_already_exists

data/app/subscribers/spree/carton_shipped_mailer_subscriber.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Spree
+  # Mailing after {Spree::Carton} is created.
+  class CartonShippedMailerSubscriber
+    include Omnes::Subscriber
+
+    handle :carton_shipped,
+           with: :send_carton_shipped_emails,
+           id: :spree_carton_mailer_send_carton_shipped_email
+
+    # Sends carton shipped emails to users.
+    #
+    # @param event [Omnes::UnstructuredEvent]
+    def send_carton_shipped_emails(event)
+      carton = event[:carton]
+
+      return if carton.suppress_email
+
+      # Do not send emails for unfulfillable cartons (i.e. for digital goods).
+      return unless carton.stock_location.fulfillable?
+
+      carton.orders.each do |order|
+        Spree::Config.carton_shipped_email_class
+          .shipped_email(order:, carton:)
+          .deliver_later
+      end
+    end
+  end
+end

data/app/subscribers/spree/order_cancel_mailer_subscriber.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Spree
+  # Mailing after {Spree::Order} is cancelled.
+  class OrderCancelMailerSubscriber
+    include Omnes::Subscriber
+
+    handle :order_canceled,
+           with: :send_cancel_email,
+           id: :spree_order_mailer_send_cancel_email
+
+    # Sends cancellation email to the user.
+    #
+    # @param event [Omnes::UnstructuredEvent]
+    def send_cancel_email(event)
+      order = event[:order]
+
+      Spree::Config.order_mailer_class.cancel_email(order).deliver_later
+    end
+  end
+end

data/app/subscribers/spree/order_confirmation_mailer_subscriber.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Spree
+  # Mailing after {Spree::Order} is confirmed.
+  class OrderConfirmationMailerSubscriber
+    include Omnes::Subscriber
+
+    handle :order_finalized,
+           with: :send_confirmation_email,
+           id: :spree_order_mailer_send_confirmation_email
+
+    # Sends confirmation email to the user.
+    #
+    # @param event [Omnes::UnstructuredEvent]
+    def send_confirmation_email(event)
+      order = event[:order]
+      unless order.confirmation_delivered?
+        Spree::Config.order_mailer_class.confirm_email(order).deliver_later
+        order.update_column(:confirmation_delivered, true)
+      end
+    end
+  end
+end

data/app/subscribers/spree/order_inventory_cancellation_mailer_subscriber.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Spree
+  # Mailing after inventory units have been cancelled from a {Spree::Order}
+  class OrderInventoryCancellationMailerSubscriber
+    include Omnes::Subscriber
+
+    handle :order_short_shipped,
+           with: :send_inventory_cancellation_email,
+           id: :spree_order_mailer_send_inventory_cancellation_email
+
+    # Sends inventory cancellation email to the user.
+    #
+    # @param event [Omnes::UnstructuredEvent]
+    def send_inventory_cancellation_email(event)
+      return unless Spree::OrderCancellations.send_cancellation_mailer
+
+      order = event[:order]
+      inventory_units = event[:inventory_units]
+
+      Spree::Config
+        .order_mailer_class
+        .inventory_cancellation_email(order, inventory_units.to_a)
+        .deliver_later
+    end
+  end
+end