solidus_core 2.10.1 → 2.11.2

data/app/models/spree/promotion.rb

@@ -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?
@@ -164,10 +176,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 +269,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/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_action.rb

@@ -1,18 +1,12 @@
 # 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, optional: true
 

data/app/models/spree/promotion_code.rb

@@ -5,8 +5,9 @@ class Spree::PromotionCode < Spree::Base
   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
 
@@ -37,6 +38,10 @@ class Spree::PromotionCode < Spree::Base
     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.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Spree
-  class PromotionCodeBatch < ActiveRecord::Base
+  class PromotionCodeBatch < Spree::Base
     class CantProcessStartedBatch < StandardError
     end
 

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

@@ -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,7 +1,7 @@
 # frozen_string_literal: true
 
 module Spree
-  class PromotionRuleRole < ActiveRecord::Base
+  class PromotionRuleRole < Spree::Base
     belongs_to :promotion_rule, class_name: 'Spree::PromotionRule', optional: true
     belongs_to :role, class_name: 'Spree::Role', optional: true
   end

data/app/models/spree/refund.rb

@@ -10,13 +10,16 @@ module Spree
 
     validates :payment, presence: true
     validates :reason, presence: true
-    validates :transaction_id, presence: true, on: :update # can't require this on create because the before_create needs to run first
     validates :amount, presence: true, numericality: { greater_than: 0 }
 
     validate :amount_is_less_than_or_equal_to_allowed_amount, on: :create
 
+    attr_reader :perform_response
+    attr_accessor :perform_after_create
+
+    after_create :set_perform_after_create_default
     after_create :perform!
-    after_create :create_log_entry
+    after_create :clear_perform_after_create
 
     scope :non_reimbursement, -> { where(reimbursement_id: nil) }
 
@@ -37,22 +40,71 @@ module Spree
       payment.payment_method.name
     end
 
-    private
-
-    # attempts to perform the refund.
+    # Must be called for the refund transaction to be processed.
+    #
+    # Attempts to perform the refund,
     # raises an error if the refund fails.
     def perform!
+      return true if perform_after_create == false
       return true if transaction_id.present?
 
       credit_cents = money.cents
 
-      @response = process!(credit_cents)
+      @perform_response = process!(credit_cents)
+
+      @response = Spree::DeprecatedInstanceVariableProxy.new(
+        self,
+        :perform_response,
+        :@response,
+        Spree::Deprecation,
+        "Please, do not use Spree::Refund @response anymore, use Spree::Refund#perform_response"
+      )
+
+      log_entries.build(details: perform_response.to_yaml)
+
+      self.transaction_id = perform_response.authorization
+      # This is needed otherwise set_perform_after_create_default callback
+      # will print a deprecation warning when save! creates a record.
+      self.perform_after_create = false unless persisted?
+      save!
 
-      self.transaction_id = @response.authorization
-      update_columns(transaction_id: transaction_id)
       update_order
     end
 
+    private
+
+    # This callback takes care of setting the behavior that determines if it is needed
+    # to execute the perform! callback after_create.
+    # Existing code that creates refund without explicitely passing
+    #
+    # perform_after_create: false
+    #
+    # as attribute will still call perform! but a deprecation warning is emitted in order
+    # to ask users to change their code with the new supported behavior.
+    def set_perform_after_create_default
+      return true if perform_after_create == false
+
+      Spree::Deprecation.warn <<-WARN.strip_heredoc, caller
+        From Solidus v3.0 onwards, #perform! will need to be explicitly called when creating new
+        refunds. Please, change your code from:
+
+          Spree::Refund.create(your: attributes)
+
+        to:
+
+          Spree::Refund.create(your: attributes, perform_after_create: false).perform!
+      WARN
+
+      self.perform_after_create = true
+    end
+
+    # This is needed to avoid that when you create a refund with perform_after_create = false,
+    # it's not possibile to call perform! on that instance, since the value of this attribute
+    # will remain false until a reload of the instance.
+    def clear_perform_after_create
+      @perform_after_create = nil
+    end
+
     # return an activemerchant response object if successful or else raise an error
     def process!(credit_cents)
       response = if payment.payment_method.payment_profiles_supported?
@@ -73,10 +125,6 @@ module Spree
       raise Core::GatewayError.new(I18n.t('spree.unable_to_connect_to_gateway'))
     end
 
-    def create_log_entry
-      log_entries.create!(details: @response.to_yaml)
-    end
-
     def amount_is_less_than_or_equal_to_allowed_amount
       if payment && amount > payment.credit_allowed
         errors.add(:amount, :greater_than_allowed)

data/app/models/spree/reimbursement.rb

@@ -104,10 +104,20 @@ module Spree
       if unpaid_amount_within_tolerance?
         reimbursed!
         Spree::Event.fire 'reimbursement_reimbursed', reimbursement: self
+        if reimbursement_success_hooks.any?
+          Spree::Deprecation.warn \
+            "reimbursement_success_hooks are deprecated. Please remove them " \
+            "and subscribe to `reimbursement_reimbursed` event instead", caller(1)
+        end
         reimbursement_success_hooks.each { |hook| hook.call self }
       else
         errored!
         Spree::Event.fire 'reimbursement_errored', reimbursement: self
+        if reimbursement_failure_hooks.any?
+          Spree::Deprecation.warn \
+            "reimbursement_failure_hooks are deprecated. Please remove them " \
+            "and subscribe to `reimbursement_errored` event instead", caller(1)
+        end
         reimbursement_failure_hooks.each { |hook| hook.call self }
       end
 
@@ -153,6 +163,23 @@ module Spree
       perform!(created_by: created_by)
     end
 
+    # The returned category is used as the category
+    # for Spree::Reimbursement::Credit.default_creditable_class.
+    #
+    # @return [Spree::StoreCreditCategory]
+    def store_credit_category
+      if Spree::Config.use_legacy_store_credit_reimbursement_category_name
+        Spree::Deprecation.warn("Using the legacy reimbursement_category_name is deprecated. "\
+          "Set Spree::Config.use_legacy_store_credit_reimbursement_category_name to false to use "\
+          "the new version instead.", caller)
+
+        name = Spree::StoreCreditCategory.reimbursement_category_name
+        return Spree::StoreCreditCategory.find_by(name: name) || Spree::StoreCreditCategory.first
+      end
+
+      Spree::StoreCreditCategory.find_by(name: Spree::StoreCreditCategory::REIMBURSEMENT)
+    end
+
     private
 
     def calculate_total

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

@@ -34,10 +34,17 @@ module Spree
       refund = reimbursement.refunds.build({
         payment: payment,
         amount: amount,
-        reason: Spree::RefundReason.return_processing_reason
+        reason: Spree::RefundReason.return_processing_reason,
+        perform_after_create: false
       })
 
-      simulate ? refund.readonly! : refund.save!
+      if simulate
+        refund.readonly!
+      else
+        refund.save!
+        refund.perform!
+      end
+
       refund
     end
 
@@ -54,7 +61,7 @@ module Spree
       Spree::Reimbursement::Credit.default_creditable_class.new(
         user: reimbursement.order.user,
         amount: unpaid_amount,
-        category: Spree::StoreCreditCategory.reimbursement_category(reimbursement),
+        category: reimbursement.store_credit_category,
         created_by: created_by,
         memo: "Refund for uncreditable payments on order #{reimbursement.order.number}",
         currency: reimbursement.order.currency

data/app/models/spree/return_authorization.rb

@@ -31,7 +31,7 @@ module Spree
     self.whitelisted_ransackable_attributes = ['memo']
 
     def total_excluding_vat
-      return_items.map(&:total_excluding_vat).sum
+      return_items.sum(&:total_excluding_vat)
     end
     alias pre_tax_total total_excluding_vat
     deprecate pre_tax_total: :total_excluding_vat, deprecator: Spree::Deprecation

data/app/models/spree/return_item.rb

@@ -90,8 +90,13 @@ module Spree
       COMPLETED_RECEPTION_STATUSES.map(&:to_s).include?(reception_status.to_s)
     end
 
-
-    attr_accessor :skip_customer_return_processing
+    def skip_customer_return_processing=(value)
+      @skip_customer_return_processing = value
+      Deprecation.warn \
+        'From Solidus v2.11 onwards, #skip_customer_return_processing does ' \
+        'nothing, and #process_inventory_unit! will restore calling ' \
+        'customer_return#process_return!', caller(1)
+    end
 
     # @param inventory_unit [Spree::InventoryUnit] the inventory for which we
     #   want a return item
@@ -196,13 +201,19 @@ module Spree
 
     def process_inventory_unit!
       inventory_unit.return!
-      if customer_return
-        customer_return.stock_location.restock(inventory_unit.variant, 1, customer_return) if should_restock?
-        unless skip_customer_return_processing
-          Deprecation.warn 'From Solidus v2.9 onwards, #process_inventory_unit! will not call customer_return#process_return!'
-          customer_return.process_return!
-        end
+
+      if should_restock?
+        customer_return.stock_location.restock(inventory_unit.variant, 1, customer_return)
       end
+
+      unless @skip_customer_return_processing.nil?
+        Deprecation.warn \
+          'From Solidus v2.11 onwards, #skip_customer_return_processing does ' \
+          'nothing, and #process_inventory_unit! will restore calling ' \
+          'customer_return#process_return!'
+      end
+
+      customer_return&.process_return!
     end
 
     def sibling_intended_for_exchange(status)
@@ -276,9 +287,9 @@ module Spree
     end
 
     def should_restock?
-      resellable? &&
+      customer_return &&
+        resellable? &&
         variant.should_track_inventory? &&
-        customer_return &&
         customer_return.stock_location.restock_inventory?
     end
   end

data/app/models/spree/return_item/exchange_variant_eligibility/same_option_value.rb

@@ -23,7 +23,7 @@ module Spree
         # blue pants with 34 waist and 32 inseam
 
         def self.eligible_variants(variant, options = {})
-          product_variants = SameProduct.eligible_variants(variant, options).includes(option_values: :option_type)
+          product_variants = SameProduct.eligible_variants(variant, **options).includes(option_values: :option_type)
           relevant_option_values = variant.option_values.select { |ov| option_type_restrictions.include? ov.option_type.name }
 
           if relevant_option_values.present?

data/app/models/spree/role.rb

@@ -5,7 +5,7 @@ module Spree
     has_many :role_users, class_name: "Spree::RoleUser", dependent: :destroy
     has_many :users, through: :role_users
 
-    validates_uniqueness_of :name
+    validates_uniqueness_of :name, case_sensitive: true
 
     def admin?
       name == "admin"