solidus_core 2.10.5 → 3.0.8

data/app/models/spree/payment_method.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'discard'
+require 'spree/preferences/persistable'
 require 'spree/preferences/statically_configurable'
 
 module Spree
@@ -12,26 +12,15 @@ module Spree
   # This class is not meant to be instantiated. Please create instances of concrete payment methods.
   #
   class PaymentMethod < Spree::Base
+    include Spree::Preferences::Persistable
+
     preference :server, :string, default: 'test'
     preference :test_mode, :boolean, default: true
 
-    acts_as_paranoid
-    include Spree::ParanoiaDeprecations
-
-    include Discard::Model
-    self.discard_column = :deleted_at
+    include Spree::SoftDeletable
 
     acts_as_list
 
-    # @private
-    def self.const_missing(name)
-      if name == :DISPLAY
-        const_set(:DISPLAY, [:both, :front_end, :back_end])
-      else
-        super
-      end
-    end
-
     validates :name, :type, presence: true
 
     has_many :payments, class_name: "Spree::Payment", inverse_of: :payment_method
@@ -63,56 +52,14 @@ module Spree
           @human
         ].compact
         options = { scope: [:activerecord, :models], count: 1, default: defaults }.merge!(options.except(:default))
-        I18n.translate(defaults.shift, options)
+        I18n.translate(defaults.shift, **options)
       end
     end
 
     class << self
-      # @deprecated Use Spree::Config.environment.payment_methods instead
-      def providers
-        Spree::Deprecation.warn 'Spree::PaymentMethod.providers is deprecated and will be deleted in Solidus 3.0. ' \
-          'Please use Rails.application.config.spree.payment_methods instead'
-        Spree::Config.environment.payment_methods
-      end
-
-      # @deprecated Use {.active}, {.available_to_users}, and {.available_to_admin} scopes instead.
-      def available(display_on = nil, store: nil)
-        Spree::Deprecation.warn "Spree::PaymentMethod.available is deprecated."\
-          "Please use .active, .available_to_users, and .available_to_admin scopes instead."\
-          "For payment methods associated with a specific store, use Spree::PaymentMethod.available_to_store(your_store)"\
-          " as the base applying any further filtering"
-
-        display_on = display_on.to_s
-
-        available_payment_methods =
-          case display_on
-          when 'front_end'
-            active.available_to_users
-          when 'back_end'
-            active.available_to_admin
-          else
-            active.available_to_users.available_to_admin
-          end
-        available_payment_methods.select do |payment|
-          store.nil? || store.payment_methods.empty? || store.payment_methods.include?(payment)
-        end
-      end
-
       def model_name
         ModelName.new(self, Spree)
       end
-
-      # @deprecated Use .active.any? instead
-      def active?
-        Spree::Deprecation.warn "#{self}.active? is deprecated. Use #{self}.active.any? instead"
-        where(type: to_s, active: true).count > 0
-      end
-
-      # @deprecated Use .with_deleted.find instead
-      def find_with_destroyed(*args)
-        Spree::Deprecation.warn "#{self}.find_with_destroyed is deprecated. Use #{self}.with_deleted.find instead"
-        unscoped { find(*args) }
-      end
     end
 
     # Represents the gateway of this payment method
@@ -139,8 +86,6 @@ module Spree
 
       @gateway ||= gateway_class.new(gateway_options)
     end
-    alias_method :provider, :gateway
-    deprecate provider: :gateway, deprecator: Spree::Deprecation
 
     # Represents all preferences as a Hash
     #
@@ -160,29 +105,6 @@ module Spree
       raise ::NotImplementedError, "You must implement payment_source_class method for #{self.class}."
     end
 
-    # @deprecated Use {Spree::PaymentMethod#available_to_users=} and {Spree::PaymentMethod#available_to_admin=} instead
-    def display_on=(value)
-      Spree::Deprecation.warn "Spree::PaymentMethod#display_on= is deprecated."\
-        "Please use #available_to_users= and #available_to_admin= instead."
-      self.available_to_users = value.blank? || value == 'front_end'
-      self.available_to_admin = value.blank? || value == 'back_end'
-    end
-
-    # @deprecated Use {Spree::PaymentMethod#available_to_users} and {Spree::PaymentMethod#available_to_admin} instead
-    def display_on
-      Spree::Deprecation.warn "Spree::PaymentMethod#display_on is deprecated."\
-        "Please use #available_to_users and #available_to_admin instead."
-      if available_to_users? && available_to_admin?
-        ''
-      elsif available_to_users?
-        'front_end'
-      elsif available_to_admin?
-        'back_end'
-      else
-        'none'
-      end
-    end
-
     # Used as partial name for your payment method
     #
     # Currently your payment method needs to provide these partials:
@@ -203,21 +125,7 @@ module Spree
     #     The view that represents your payment method on orders through the api
     #
     def partial_name
-      deprecated_method_type_override || type.demodulize.underscore
-    end
-
-    # :nodoc:
-    # If method_type has been overridden, call it and return the value, otherwise return nil
-    def deprecated_method_type_override
-      if method(:method_type).owner != Spree::PaymentMethod
-        Spree::Deprecation.warn "#{method(:method_type).owner} is overriding PaymentMethod#method_type. This is deprecated and will be removed from Solidus 3.0 (override partial_name instead).", caller[1..-1]
-        method_type
-      end
-    end
-
-    def method_type
-      Spree::Deprecation.warn "method_type is deprecated and will be removed from Solidus 3.0 (use partial_name instead)", caller
-      partial_name
+      type.demodulize.underscore
     end
 
     def payment_profiles_supported?
@@ -275,14 +183,7 @@ module Spree
     # Represents the gateway class of this payment method
     #
     def gateway_class
-      if respond_to? :provider_class
-        Spree::Deprecation.warn \
-          "provider_class is deprecated and will be removed from Solidus 3.0 " \
-          "(use gateway_class instead)"
-        public_send :provider_class
-      else
-        raise ::NotImplementedError, "You must implement gateway_class method for #{self.class}."
-      end
+      raise ::NotImplementedError, "You must implement gateway_class method for #{self.class}."
     end
   end
 end

data/app/models/spree/payment_source.rb

@@ -23,9 +23,9 @@ module Spree
     end
 
     # @param payment [Spree::Payment] the payment we want to know if can be voided
-    # @return [Boolean] true when the payment is not failed or voided
+    # @return [Boolean] true when the payment is not failed, voided or invalid
     def can_void?(payment)
-      !payment.failed? && !payment.void?
+      payment.can_void?
     end
 
     # Indicates whether its possible to credit the payment.  Note that most

data/app/models/spree/preference.rb

@@ -3,5 +3,5 @@
 class Spree::Preference < Spree::Base
   serialize :value
 
-  validates :key, presence: true, uniqueness: { allow_blank: true }
+  validates :key, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
 end

data/app/models/spree/price.rb

@@ -1,18 +1,12 @@
 # frozen_string_literal: true
 
-require 'discard'
-
 module Spree
   class Price < Spree::Base
-    acts_as_paranoid
-    include Spree::ParanoiaDeprecations
-
-    include Discard::Model
-    self.discard_column = :deleted_at
+    include Spree::SoftDeletable
 
     MAXIMUM_AMOUNT = BigDecimal('99_999_999.99')
 
-    belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant', touch: true, optional: true
+    belongs_to :variant, -> { with_discarded }, class_name: 'Spree::Variant', touch: true, optional: true
     belongs_to :country, class_name: "Spree::Country", foreign_key: "country_iso", primary_key: "iso", optional: true
 
     delegate :product, to: :variant
@@ -61,7 +55,7 @@ module Spree
 
     def display_country
       if country_iso
-        "#{country_iso} (#{country.name})"
+        "#{country_iso} (#{I18n.t(country_iso, scope: [:spree, :country_names])})"
       else
         I18n.t(:any_country, scope: [:spree, :admin, :prices])
       end

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

@@ -29,11 +29,13 @@ module Spree
           scope :descend_by_name, -> { order(name: :desc) }
 
           add_search_scope :ascend_by_master_price do
-            joins(master: :default_price).order(Spree::Price.arel_table[:amount].asc)
+            joins(master: :default_price).select('spree_products.* , spree_prices.amount')
+                                         .order(Spree::Price.arel_table[:amount].asc)
           end
 
           add_search_scope :descend_by_master_price do
-            joins(master: :default_price).order(Spree::Price.arel_table[:amount].desc)
+            joins(master: :default_price).select('spree_products.* , spree_prices.amount')
+                                         .order(Spree::Price.arel_table[:amount].desc)
           end
 
           add_search_scope :price_between do |low, high|
@@ -68,7 +70,6 @@ module Spree
           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)
           end
 
@@ -182,7 +183,10 @@ module Spree
           end
           # Can't use add_search_scope for this as it needs a default argument
           def self.available(available_on = nil)
-            with_master_price.where("#{Spree::Product.quoted_table_name}.available_on <= ?", available_on || Time.current)
+            with_master_price
+              .where("#{Spree::Product.quoted_table_name}.available_on <= ?", available_on || Time.current)
+              .where("#{Spree::Product.quoted_table_name}.discontinue_on IS NULL OR" \
+                     "#{Spree::Product.quoted_table_name}.discontinue_on >= ?", Time.current)
           end
           search_scopes << :available
 
@@ -197,33 +201,6 @@ module Spree
             where(subquery.arel.exists)
           end
 
-          def self.distinct_by_product_ids(sort_order = nil)
-            Spree::Deprecation.warn "Product.distinct_by_product_ids is deprecated and should not be used"
-
-            sort_column = sort_order.split(" ").first
-
-            # Postgres will complain when using ordering by expressions not present in
-            # SELECT DISTINCT. e.g.
-            #
-            #   PG::InvalidColumnReference: ERROR:  for SELECT DISTINCT, ORDER BY
-            #   expressions must appear in select list. e.g.
-            #
-            #   SELECT  DISTINCT "spree_products".* FROM "spree_products" LEFT OUTER JOIN
-            #   "spree_variants" ON "spree_variants"."product_id" = "spree_products"."id" AND "spree_variants"."is_master" = 't'
-            #   AND "spree_variants"."deleted_at" IS NULL LEFT OUTER JOIN "spree_prices" ON
-            #   "spree_prices"."variant_id" = "spree_variants"."id" AND "spree_prices"."currency" = 'USD'
-            #   AND "spree_prices"."deleted_at" IS NULL WHERE "spree_products"."deleted_at" IS NULL AND ('t'='t')
-            #   ORDER BY "spree_prices"."amount" ASC LIMIT 10 OFFSET 0
-            #
-            # Don't allow sort_column, a variable coming from params,
-            # to be anything but a column in the database
-            if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' && !column_names.include?(sort_column)
-              all
-            else
-              distinct
-            end
-          end
-
           class << self
             private
 
@@ -233,7 +210,7 @@ module Spree
 
             # specifically avoid having an order for taxon search (conflicts with main order)
             def prepare_taxon_conditions(taxons)
-              ids = taxons.map { |taxon| taxon.self_and_descendants.pluck(:id) }.flatten.uniq
+              ids = taxons.flat_map { |taxon| taxon.self_and_descendants.pluck(:id) }.uniq
               joins(:taxons).where("#{Spree::Taxon.table_name}.id" => ids)
             end
 

data/app/models/spree/product.rb

@@ -1,25 +1,15 @@
 # frozen_string_literal: true
 
-require 'discard'
-
 module Spree
   # Products represent an entity for sale in a store. Products can have
   # variations, called variants. Product properties include description,
   # permalink, availability, shipping category, etc. that do not change by
   # variant.
-  #
-  # @note this model uses {https://github.com/radar/paranoia paranoia}.
-  #   +#destroy+ will only soft-destroy records and the default scope hides
-  #   soft-destroyed records using +WHERE deleted_at IS NULL+.
   class Product < Spree::Base
     extend FriendlyId
     friendly_id :slug_candidates, use: :history
 
-    acts_as_paranoid
-    include Spree::ParanoiaDeprecations
-
-    include Discard::Model
-    self.discard_column = :deleted_at
+    include Spree::SoftDeletable
 
     after_discard do
       variants_including_master.discard_all
@@ -48,7 +38,7 @@ module Spree
     belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :products, optional: true
 
     has_one :master,
-      -> { where(is_master: true).with_deleted },
+      -> { where(is_master: true).with_discarded },
       inverse_of: :product,
       class_name: 'Spree::Variant',
       autosave: true
@@ -95,7 +85,6 @@ module Spree
              :has_default_price?,
              :images,
              :price_for,
-             :price_in,
              :rebuild_vat_prices=,
              to: :find_or_build_master
 
@@ -121,7 +110,7 @@ module Spree
     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 }
+    validates :slug, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
 
     attr_accessor :option_values_hash
 
@@ -134,7 +123,7 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[name slug]
 
     def self.ransackable_scopes(_auth_object = nil)
-      %i(with_deleted with_variant_sku_cont)
+      %i(with_discarded with_variant_sku_cont)
     end
 
     # @return [Boolean] true if there are any variants
@@ -174,25 +163,23 @@ module Spree
     end
 
     # Determines if product is available. A product is available if it has not
-    # been deleted and the available_on date is in the past.
+    # been deleted, the available_on date is in the past
+    # and the discontinue_on date is nil or in the future.
     #
     # @return [Boolean] true if this product is available
     def available?
-      !(available_on.nil? || available_on.future?) && !deleted?
+      !deleted? && available_on&.past? && !discontinued?
     end
 
-    # Groups variants by the specified option type.
+    # Determines if product is discontinued.
     #
-    # @deprecated This method is not called in the Solidus codebase
-    # @param opt_type [String] the name of the option type to group by
-    # @param pricing_options [Spree::Config.pricing_options_class] the pricing options to search
-    #   for, default: the default pricing options
-    # @return [Hash] option_type as keys, array of variants as values.
-    def categorise_variants_from_option(opt_type, pricing_options = Spree::Config.default_pricing_options)
-      return {} unless option_types.include?(opt_type)
-      variants.with_prices(pricing_options).group_by { |variant| variant.option_values.detect { |option| option.option_type == opt_type } }
+    # A product is discontinued if the discontinue_on date
+    # is not nil and in the past.
+    #
+    # @return [Boolean] true if this product is discontinued
+    def discontinued?
+      !!discontinue_on&.past?
     end
-    deprecate :categorise_variants_from_option, deprecator: Spree::Deprecation
 
     # Poor man's full text search.
     #
@@ -209,17 +196,6 @@ module Spree
       where conditions.inject(:or)
     end
 
-    # @param current_currency [String] currency to filter variants by; defaults to Spree's default
-    # @deprecated This method can only handle prices for currencies
-    # @return [Array<Spree::Variant>] all variants with at least one option value
-    def variants_and_option_values(current_currency = nil)
-      variants.includes(:option_values).active(current_currency).select do |variant|
-        variant.option_values.any?
-      end
-    end
-    deprecate variants_and_option_values: :variants_and_option_values_for,
-              deprecator: Spree::Deprecation
-
     # @param pricing_options [Spree::Variant::PricingOptions] the pricing options to search
     #   for, default: the default pricing options
     # @return [Array<Spree::Variant>] all variants with at least one option value
@@ -291,16 +267,6 @@ module Spree
       end
     end
 
-    # Image that can be used for the product.
-    #
-    # Will first search for images on the product, then those belonging to the
-    # 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
-
     # Finds the variant property rule that matches the provided option value ids.
     #
     # @param option_value_ids [Array<Integer>] list of option value ids
@@ -361,8 +327,14 @@ module Spree
     # If the master is invalid, the Product object will be assigned its errors
     def validate_master
       unless master.valid?
-        master.errors.each do |att, error|
-          errors.add(att, error)
+        if Gem::Requirement.new(">= 6.1").satisfied_by?(Rails.gem_version)
+          master.errors.each do |error|
+            errors.add(error.attribute, error.message)
+          end
+        else
+          master.errors.each do |att, error|
+            errors.add(att, error)
+          end
         end
       end
     end
@@ -381,11 +353,11 @@ module Spree
 
     # Iterate through this product's taxons and taxonomies and touch their timestamps in a batch
     def touch_taxons
-      taxons_to_touch = taxons.map(&:self_and_ancestors).flatten.uniq
+      taxons_to_touch = taxons.flat_map(&:self_and_ancestors).uniq
       unless taxons_to_touch.empty?
         Spree::Taxon.where(id: taxons_to_touch.map(&:id)).update_all(updated_at: Time.current)
 
-        taxonomy_ids_to_touch = taxons_to_touch.map(&:taxonomy_id).flatten.uniq
+        taxonomy_ids_to_touch = taxons_to_touch.flat_map(&:taxonomy_id).uniq
         Spree::Taxonomy.where(id: taxonomy_ids_to_touch).update_all(updated_at: Time.current)
       end
     end

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

@@ -39,9 +39,6 @@ module Spree
         # item_total and ship_total
         def compute_amount(calculable)
           amount = calculator.compute(calculable)
-          if !amount.is_a?(BigDecimal)
-            Spree::Deprecation.warn "#{calculator.class.name}#compute returned #{amount.inspect}, it should return a BigDecimal"
-          end
           amount ||= BigDecimal(0)
           amount = amount.abs
           [(calculable.item_total + calculable.ship_total), amount].min * -1

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

@@ -33,9 +33,6 @@ module Spree
           order = adjustable.is_a?(Order) ? adjustable : adjustable.order
           return 0 unless promotion.line_item_actionable?(order, adjustable)
           promotion_amount = calculator.compute(adjustable)
-          if !promotion_amount.is_a?(BigDecimal)
-            Spree::Deprecation.warn "#{calculator.class.name}#compute returned #{promotion_amount.inspect}, it should return a BigDecimal"
-          end
           promotion_amount ||= BigDecimal(0)
           promotion_amount = promotion_amount.abs
           [adjustable.amount, promotion_amount].min * -1

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

@@ -57,9 +57,6 @@ module Spree
         #
         def compute_amount(line_item)
           adjustment_amount = calculator.compute(PartialLineItem.new(line_item))
-          if !adjustment_amount.is_a?(BigDecimal)
-            Spree::Deprecation.warn "#{calculator.class.name}#compute returned #{adjustment_amount.inspect}, it should return a BigDecimal"
-          end
           adjustment_amount ||= BigDecimal(0)
           adjustment_amount = adjustment_amount.abs
 

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? { |result| result == true }
+          created_adjustments.any?
         end
 
         def label

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

@@ -38,11 +38,7 @@ module Spree
               eligibility_errors.add(:base, eligibility_error_message(:has_excluded_taxon), error_code: :has_excluded_taxon)
             end
           else
-            # Change this to an exception in a future version of Solidus
-            warn_invalid_match_policy(assume: 'any')
-            unless order_taxons.where(id: rule_taxon_ids_with_children).exists?
-              eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons), error_code: :no_matching_taxons)
-            end
+            raise "unexpected match policy: #{preferred_match_policy.inspect}"
           end
 
           eligibility_errors.empty?
@@ -60,9 +56,7 @@ module Spree
           when 'none'
             !found
           else
-            # Change this to an exception in a future version of Solidus
-            warn_invalid_match_policy(assume: 'any')
-            found
+            raise "unexpected match policy: #{preferred_match_policy.inspect}"
           end
         end
 
@@ -77,13 +71,6 @@ module Spree
 
         private
 
-        def warn_invalid_match_policy(assume:)
-          Spree::Deprecation.warn(
-            "#{self.class.name} id=#{id} has unexpected match policy #{preferred_match_policy.inspect}. "\
-            "Interpreting it as '#{assume}'."
-          )
-        end
-
         # All taxons in an order
         def taxons_in_order(order)
           Spree::Taxon.joins(products: { variants_including_master: :line_items })

data/app/models/spree/promotion.rb

@@ -28,26 +28,34 @@ 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
+    scope :active, -> { has_actions.started_and_unexpired }
+    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 +89,7 @@ module Spree
     end
 
     def active?
-      started? && not_expired?
+      started? && not_expired? && actions.present?
     end
 
     def inactive?
@@ -164,10 +172,10 @@ 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
@@ -257,10 +265,9 @@ 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
 

data/app/models/spree/promotion_action.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'discard'
+require 'spree/preferences/persistable'
 
 module Spree
   # Base class for all types of promotion action.
@@ -8,11 +8,8 @@ module Spree
   # 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::Preferences::Persistable
+    include Spree::SoftDeletable
 
     belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions, optional: true
 
@@ -35,15 +32,8 @@ module Spree
     #
     # @param order [Spree::Order] the order to remove the action from
     # @return [void]
-    def remove_from(order)
-      Spree::Deprecation.warn("#{self.class.name.inspect} does not define #remove_from. The default behavior may be incorrect and will be removed in a future version of Solidus.", caller)
-      [order, *order.line_items, *order.shipments].each do |item|
-        item.adjustments.each do |adjustment|
-          if adjustment.source == self
-            item.adjustments.destroy(adjustment)
-          end
-        end
-      end
+    def remove_from(_order)
+      raise 'remove_from should be implemented in a sub-class of PromotionAction'
     end
 
     def to_partial_path