solidus_core 2.9.6 → 2.11.0

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
-    belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :product_option_types
+    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
     acts_as_list scope: :product
   end
 end

data/app/models/spree/product_promotion_rule.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class ProductPromotionRule < Spree::Base
-    belongs_to :product
-    belongs_to :promotion_rule
+    belongs_to :product, optional: true
+    belongs_to :promotion_rule, optional: true
   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
-    belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties
+    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
 
     self.whitelisted_ransackable_attributes = ['value']
   end

data/app/models/spree/promotion.rb

@@ -7,7 +7,7 @@ module Spree
 
     attr_reader :eligibility_errors
 
-    belongs_to :promotion_category
+    belongs_to :promotion_category, optional: true
 
     has_many :promotion_rules, autosave: true, dependent: :destroy, inverse_of: :promotion
     alias_method :rules, :promotion_rules
@@ -28,26 +28,38 @@ module Spree
     validates_associated :rules
 
     validates :name, presence: true
-    validates :path, uniqueness: { allow_blank: true }
+    validates :path, uniqueness: { allow_blank: true, case_sensitive: true }
     validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
     validates :per_code_usage_limit, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
     validates :description, length: { maximum: 255 }
-    validate :apply_automatically_disallowed_with_codes_or_paths
+    validate :apply_automatically_disallowed_with_paths
 
     before_save :normalize_blank_values
 
     scope :coupons, -> { joins(:codes).distinct }
     scope :advertised, -> { where(advertise: true) }
     scope :active, -> do
+      return started_and_unexpired if Spree::Config.consider_actionless_promotion_active == true
+
+      has_actions.started_and_unexpired
+    end
+    scope :started_and_unexpired, -> do
       table = arel_table
       time = Time.current
+
       where(table[:starts_at].eq(nil).or(table[:starts_at].lt(time))).
         where(table[:expires_at].eq(nil).or(table[:expires_at].gt(time)))
     end
+    scope :has_actions, -> do
+      joins(:promotion_actions)
+    end
     scope :applied, -> { joins(:order_promotions).distinct }
 
     self.whitelisted_ransackable_associations = ['codes']
     self.whitelisted_ransackable_attributes = %w[name path promotion_category_id]
+    def self.ransackable_scopes(*)
+      %i(active)
+    end
 
     def self.order_activatable?(order)
       order && !UNACTIVATABLE_ORDER_STATES.include?(order.state)
@@ -81,7 +93,7 @@ module Spree
     end
 
     def active?
-      started? && not_expired?
+      started? && not_expired? && (Spree::Config.consider_actionless_promotion_active || actions.present?)
     end
 
     def inactive?
@@ -126,9 +138,12 @@ module Spree
     # called anytime order.recalculate happens
     def eligible?(promotable, promotion_code: nil)
       return false if inactive?
-      return false if usage_limit_exceeded?
-      return false if promotion_code && promotion_code.usage_limit_exceeded?
       return false if blacklisted?(promotable)
+
+      excluded_orders = eligibility_excluded_orders(promotable)
+      return false if usage_limit_exceeded?(excluded_orders: excluded_orders)
+      return false if promotion_code&.usage_limit_exceeded?(excluded_orders: excluded_orders)
+
       !!eligible_rules(promotable, {})
     end
 
@@ -138,7 +153,8 @@ module Spree
     def eligible_rules(promotable, options = {})
       # Promotions without rules are eligible by default.
       return [] if rules.none?
-      eligible = lambda { |r| r.eligible?(promotable, options) }
+
+      eligible = lambda { |rule| rule.eligible?(promotable, options) }
       specific_rules = rules.for(promotable)
       return [] if specific_rules.none?
 
@@ -160,28 +176,28 @@ module Spree
     end
 
     def products
-      rules.where(type: "Spree::Promotion::Rules::Product").map(&:products).flatten.uniq
+      rules.where(type: "Spree::Promotion::Rules::Product").flat_map(&:products).uniq
     end
 
-    # Whether the promotion has exceeded it's usage restrictions.
+    # Whether the promotion has exceeded its usage restrictions.
     #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage limit
     # @return true or false
-    def usage_limit_exceeded?
+    def usage_limit_exceeded?(excluded_orders: [])
       if usage_limit
-        usage_count >= usage_limit
+        usage_count(excluded_orders: excluded_orders) >= usage_limit
       end
     end
 
     # Number of times the code has been used overall
     #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
     # @return [Integer] usage count
-    def usage_count
-      Spree::Adjustment.eligible.
-        promotion.
-        where(source_id: actions.map(&:id)).
-        joins(:order).
-        merge(Spree::Order.complete).
-        distinct.
+    def usage_count(excluded_orders: [])
+      Spree::Adjustment.promotion.
+        eligible.
+        in_completed_orders(excluded_orders: excluded_orders).
+        where(source_id: actions).
         count(:order_id)
     end
 
@@ -253,10 +269,20 @@ module Spree
       match_policy == "all"
     end
 
-    def apply_automatically_disallowed_with_codes_or_paths
+    def apply_automatically_disallowed_with_paths
       return unless apply_automatically
-      errors.add(:apply_automatically, :disallowed_with_code) if codes.any?
+
       errors.add(:apply_automatically, :disallowed_with_path) if path.present?
     end
+
+    def eligibility_excluded_orders(promotable)
+      if promotable.is_a?(Spree::Order)
+        [promotable]
+      elsif promotable.respond_to?(:order)
+        [promotable.order]
+      else
+        []
+      end
+    end
   end
 end

data/app/models/spree/promotion/actions/create_quantity_adjustments.rb

@@ -67,7 +67,7 @@ module Spree
           line_items = actionable_line_items(order)
 
           actioned_line_items = order.line_item_adjustments.reload.
-            select { |a| a.source == self && a.amount < 0 }.
+            select { |adjustment| adjustment.source == self && adjustment.amount < 0 }.
             map(&:adjustable)
           other_line_items = actioned_line_items - [line_item]
 

data/app/models/spree/promotion/actions/free_shipping.rb

@@ -8,8 +8,9 @@ module Spree
           order = payload[:order]
           promotion_code = payload[:promotion_code]
 
-          results = order.shipments.map do |shipment|
-            return false if promotion_credit_exists?(shipment)
+          created_adjustments = order.shipments.map do |shipment|
+            next if promotion_credit_exists?(shipment)
+
             shipment.adjustments.create!(
               order: shipment.order,
               amount: compute_amount(shipment),
@@ -17,11 +18,11 @@ module Spree
               promotion_code: promotion_code,
               label: label
             )
-            true
           end
-          # Did we actually end up applying any adjustments?
+
+          # Did we actually end up creating any adjustments?
           # If so, then this action should be classed as 'successful'
-          results.any? { |r| r == true }
+          created_adjustments.any?
         end
 
         def label

data/app/models/spree/promotion/rules/option_value.rb

@@ -29,8 +29,8 @@ module Spree
         def preferred_eligible_values
           values = preferences[:eligible_values] || {}
           Hash[values.keys.map(&:to_i).zip(
-            values.values.map do |v|
-              (v.is_a?(Array) ? v : v.split(",")).map(&:to_i)
+            values.values.map do |value|
+              (value.is_a?(Array) ? value : value.split(",")).map(&:to_i)
             end
           )]
         end

data/app/models/spree/promotion/rules/product.rb

@@ -32,15 +32,15 @@ module Spree
 
           case preferred_match_policy
           when 'all'
-            unless eligible_products.all? { |p| order.products.include?(p) }
+            unless eligible_products.all? { |product| order.products.include?(product) }
               eligibility_errors.add(:base, eligibility_error_message(:missing_product), error_code: :missing_product)
             end
           when 'any'
-            unless order.products.any? { |p| eligible_products.include?(p) }
+            unless order.products.any? { |product| eligible_products.include?(product) }
               eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products), error_code: :no_applicable_products)
             end
           when 'none'
-            unless order.products.none? { |p| eligible_products.include?(p) }
+            unless order.products.none? { |product| eligible_products.include?(product) }
               eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product), error_code: :has_excluded_product)
             end
           else

data/app/models/spree/promotion_action.rb

@@ -1,22 +1,16 @@
 # frozen_string_literal: true
 
-require 'discard'
-
 module Spree
   # Base class for all types of promotion action.
   #
   # PromotionActions perform the necessary tasks when a promotion is activated
   # by an event and determined to be eligible.
   class PromotionAction < Spree::Base
-    acts_as_paranoid
-    include Spree::ParanoiaDeprecations
-
-    include Discard::Model
-    self.discard_column = :deleted_at
+    include Spree::SoftDeletable
 
-    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions, optional: true
 
-    scope :of_type, ->(t) { where(type: Array.wrap(t).map(&:to_s)) }
+    scope :of_type, ->(type) { where(type: Array.wrap(type).map(&:to_s)) }
     scope :shipping, -> { of_type(Spree::Config.environment.promotions.shipping_actions.to_a) }
 
     # Updates the state of the order or performs some other action depending on

data/app/models/spree/promotion_chooser.rb

@@ -26,8 +26,8 @@ module Spree
 
     # @return The best promotion from this set of adjustments.
     def best_promotion_adjustment
-      @best_promotion_adjustment ||= @adjustments.select(&:eligible?).min_by do |a|
-        [a.amount, -a.id]
+      @best_promotion_adjustment ||= @adjustments.select(&:eligible?).min_by do |adjustment|
+        [adjustment.amount, -adjustment.id]
       end
     end
   end

data/app/models/spree/promotion_code.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 class Spree::PromotionCode < Spree::Base
-  belongs_to :promotion, inverse_of: :codes
-  belongs_to :promotion_code_batch, class_name: "Spree::PromotionCodeBatch"
+  belongs_to :promotion, inverse_of: :codes, optional: true
+  belongs_to :promotion_code_batch, class_name: "Spree::PromotionCodeBatch", optional: true
   has_many :adjustments
 
-  validates :value, presence: true, uniqueness: { allow_blank: true }
+  validates :value, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
   validates :promotion, presence: true
+  validate :promotion_not_apply_automatically, on: :create
 
   before_save :normalize_code
 
@@ -14,28 +15,33 @@ class Spree::PromotionCode < Spree::Base
 
   # Whether the promotion code has exceeded its usage restrictions
   #
+  # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage limit
   # @return true or false
-  def usage_limit_exceeded?
+  def usage_limit_exceeded?(excluded_orders: [])
     if usage_limit
-      usage_count >= usage_limit
+      usage_count(excluded_orders: excluded_orders) >= usage_limit
     end
   end
 
   # Number of times the code has been used overall
   #
+  # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
   # @return [Integer] usage count
-  def usage_count
-    adjustments.eligible.
-      joins(:order).
-      merge(Spree::Order.complete).
-      distinct.
-      count(:order_id)
+  def usage_count(excluded_orders: [])
+    adjustments.
+    eligible.
+    in_completed_orders(excluded_orders: excluded_orders).
+    count(:order_id)
   end
 
   def usage_limit
     promotion.per_code_usage_limit
   end
 
+  def promotion_not_apply_automatically
+    errors.add(:base, :disallowed_with_apply_automatically) if promotion.apply_automatically
+  end
+
   private
 
   def normalize_code

data/app/models/spree/promotion_code/batch_builder.rb

@@ -33,12 +33,12 @@ class ::Spree::PromotionCode::BatchBuilder
   def build_promotion_codes
     generate_random_codes
     promotion_code_batch.update!(state: "completed")
-  rescue StandardError => e
+  rescue StandardError => error
     promotion_code_batch.update!(
-      error: e.inspect,
+      error: error.inspect,
       state: "failed"
     )
-    raise e
+    raise error
   end
 
   private

data/app/models/spree/promotion_code_batch.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module Spree
-  class PromotionCodeBatch < ActiveRecord::Base
+  class PromotionCodeBatch < Spree::Base
     class CantProcessStartedBatch < StandardError
     end
 
-    belongs_to :promotion, class_name: "Spree::Promotion"
+    belongs_to :promotion, class_name: "Spree::Promotion", optional: true
     has_many :promotion_codes, class_name: "Spree::PromotionCode", dependent: :destroy
 
     validates :number_of_codes, numericality: { greater_than: 0 }

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

@@ -13,9 +13,9 @@ module Spree
 
       def apply
         if coupon_code.present?
-          if promotion.present? && promotion.actions.exists?
+          if promotion.present? && promotion.active? && promotion.actions.exists?
             handle_present_promotion(promotion)
-          elsif promotion_code && promotion_code.promotion.inactive?
+          elsif promotion_code&.promotion&.expired?
             set_error_code :coupon_code_expired
           else
             set_error_code :coupon_code_not_found

data/app/models/spree/promotion_rule.rb

@@ -3,9 +3,9 @@
 module Spree
   # Base class for all promotion rules
   class PromotionRule < Spree::Base
-    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules, optional: true
 
-    scope :of_type, ->(t) { where(type: t) }
+    scope :of_type, ->(type) { where(type: type) }
 
     validates :promotion, presence: true
     validate :unique_per_promotion, on: :create
@@ -45,7 +45,7 @@ module Spree
     end
 
     def eligibility_error_message(key, options = {})
-      I18n.t(key, { scope: [:spree, :eligibility_errors, :messages] }.merge(options))
+      I18n.t(key, **{ scope: [:spree, :eligibility_errors, :messages] }.merge(options))
     end
   end
 end

data/app/models/spree/promotion_rule_role.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Spree
-  class PromotionRuleRole < ActiveRecord::Base
-    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
-    belongs_to :role, class_name: 'Spree::Role'
+  class PromotionRuleRole < Spree::Base
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule', optional: true
+    belongs_to :role, class_name: 'Spree::Role', optional: true
   end
 end

data/app/models/spree/promotion_rule_store.rb

@@ -4,7 +4,7 @@ module Spree
   class PromotionRuleStore < Spree::Base
     self.table_name = "spree_promotion_rules_stores"
 
-    belongs_to :promotion_rule, class_name: "Spree::PromotionRule"
-    belongs_to :store, class_name: "Spree::Store"
+    belongs_to :promotion_rule, class_name: "Spree::PromotionRule", optional: true
+    belongs_to :store, class_name: "Spree::Store", optional: true
   end
 end

data/app/models/spree/promotion_rule_taxon.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class PromotionRuleTaxon < Spree::Base
-    belongs_to :promotion_rule
-    belongs_to :taxon
+    belongs_to :promotion_rule, optional: true
+    belongs_to :taxon, optional: true
   end
 end

data/app/models/spree/promotion_rule_user.rb

@@ -4,7 +4,7 @@ module Spree
   class PromotionRuleUser < Spree::Base
     self.table_name = 'spree_promotion_rules_users'
 
-    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
-    belongs_to :user, class_name: Spree::UserClassHandle.new
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule', optional: true
+    belongs_to :user, class_name: Spree::UserClassHandle.new, optional: true
   end
 end