solidus_core 2.4.2 → 2.5.0.beta1

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

@@ -172,7 +172,7 @@ module Spree
     end
 
     scope :with_master_price, -> do
-      joins(:master).where(Spree::Price.where(Spree::Variant.arel_table[:id].eq(Spree::Price.arel_table[:variant_id])).exists)
+      joins(:master).where(Spree::Price.where(Spree::Variant.arel_table[:id].eq(Spree::Price.arel_table[:variant_id])).arel.exists)
     end
 
     # Can't use add_search_scope for this as it needs a default argument
@@ -189,7 +189,7 @@ module Spree
       sku_match = "%#{sku}%"
       variant_table = Spree::Variant.arel_table
       subquery = Spree::Variant.where(variant_table[:sku].matches(sku_match).and(variant_table[:product_id].eq(arel_table[:id])))
-      where(subquery.exists)
+      where(subquery.arel.exists)
     end
 
     def self.distinct_by_product_ids(sort_order = nil)

data/app/models/spree/promotion.rb

@@ -237,8 +237,7 @@ module Spree
       when Spree::LineItem
         !promotable.product.promotionable?
       when Spree::Order
-        promotable.line_items.any? &&
-          promotable.line_items.joins(:product).where(spree_products: { promotionable: false }).any?
+        promotable.line_items.joins(:product).where(spree_products: { promotionable: false }).exists?
       end
     end
 

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

@@ -10,7 +10,8 @@ module Spree
         delegate :eligible?, to: :promotion
 
         before_validation :ensure_action_has_calculator
-        before_destroy :deals_with_adjustments_for_deleted_source
+        before_destroy :remove_adjustments_from_incomplete_orders
+        before_discard :remove_adjustments_from_incomplete_orders
 
         # Creates the adjustment related to a promotion for the order passed
         # through options hash
@@ -27,7 +28,7 @@ module Spree
             order: order,
             source: self,
             promotion_code: options[:promotion_code],
-            label: Spree.t('adjustment_labels.order', promotion: Spree::Promotion.model_name.human, promotion_name: promotion.name)
+            label: I18n.t('spree.adjustment_labels.order', promotion: Spree::Promotion.model_name.human, promotion_name: promotion.name)
           )
           true
         end

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

@@ -10,20 +10,19 @@ module Spree
         delegate :eligible?, to: :promotion
 
         before_validation :ensure_action_has_calculator
-        before_destroy :deals_with_adjustments_for_deleted_source
+        before_destroy :remove_adjustments_from_incomplete_orders
+        before_discard :remove_adjustments_from_incomplete_orders
 
         def perform(payload = {})
           order = payload[:order]
           promotion = payload[:promotion]
           promotion_code = payload[:promotion_code]
 
-          result = false
-
-          line_items_to_adjust(promotion, order).each do |line_item|
-            current_result = create_adjustment(line_item, order, promotion_code)
-            result ||= current_result
+          results = line_items_to_adjust(promotion, order).map do |line_item|
+            create_adjustment(line_item, order, promotion_code)
           end
-          result
+
+          results.any?
         end
 
         # Ensure a negative amount which does not exceed the sum of the order's
@@ -64,7 +63,7 @@ module Spree
             amount: amount,
             order: order,
             promotion_code: promotion_code,
-            label: Spree.t('adjustment_labels.line_item', promotion: Spree::Promotion.model_name.human, promotion_name: promotion.name)
+            label: I18n.t('spree.adjustment_labels.line_item', promotion: Spree::Promotion.model_name.human, promotion_name: promotion.name)
           )
           true
         end

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

@@ -23,7 +23,7 @@ module Spree
         end
 
         def label
-          "#{Spree.t(:promotion)} (#{promotion.name})"
+          "#{I18n.t('spree.promotion')} (#{promotion.name})"
         end
 
         def compute_amount(shipment)

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

@@ -16,25 +16,29 @@ module Spree
         end
 
         def eligible?(order, _options = {})
-          order_taxons = taxons_in_order_including_parents(order)
+          order_taxons = taxons_in_order(order)
 
           case preferred_match_policy
           when 'all'
-            unless (taxons.to_a - order_taxons).empty?
+            matches_all = taxons.all? do |rule_taxon|
+              order_taxons.where(id: rule_taxon.self_and_descendants.ids).exists?
+            end
+
+            unless matches_all
               eligibility_errors.add(:base, eligibility_error_message(:missing_taxon))
             end
           when 'any'
-            unless taxons.any?{ |taxon| order_taxons.include? taxon }
+            unless order_taxons.where(id: rule_taxon_ids_with_children).exists?
               eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons))
             end
           when 'none'
-            unless taxons.none?{ |taxon| order_taxons.include? taxon }
+            if order_taxons.where(id: rule_taxon_ids_with_children).exists?
               eligibility_errors.add(:base, eligibility_error_message(:has_excluded_taxon))
             end
           else
             # Change this to an exception in a future version of Solidus
             warn_invalid_match_policy(assume: 'any')
-            unless taxons.any? { |taxon| order_taxons.include? taxon }
+            unless order_taxons.where(id: rule_taxon_ids_with_children).exists?
               eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons))
             end
           end
@@ -42,16 +46,24 @@ module Spree
           eligibility_errors.empty?
         end
 
+        # TODO: Fix bug - well described by jhawthorn in #1409:
+        # `eligible?` checks the configured taxons and all descendants,
+        # `actionable?` only seems to check against the taxons themselves (not children)
         def actionable?(line_item)
+          found = Spree::Classification.where(
+            product_id: line_item.variant.product_id,
+            taxon_id: taxon_ids
+          ).exists?
+
           case preferred_match_policy
           when 'any', 'all'
-            taxon_product_ids.include?(line_item.variant.product_id)
+            found
           when 'none'
-            taxon_product_ids.exclude? line_item.variant.product_id
+            !found
           else
             # Change this to an exception in a future version of Solidus
             warn_invalid_match_policy(assume: 'any')
-            taxon_product_ids.include?(line_item.variant.product_id)
+            found
           end
         end
 
@@ -74,27 +86,16 @@ module Spree
         end
 
         # All taxons in an order
-        def order_taxons(order)
-          Spree::Taxon.joins(products: { variants_including_master: :line_items }).where(spree_line_items: { order_id: order.id }).distinct
+        def taxons_in_order(order)
+          Spree::Taxon.joins(products: { variants_including_master: :line_items })
+            .where(spree_line_items: { order_id: order.id }).distinct
         end
 
         # ids of taxons rules and taxons rules children
-        def taxons_including_children_ids
-          taxons.flat_map { |taxon| taxon.self_and_descendants.ids }
-        end
-
-        # taxons order vs taxons rules and taxons rules children
-        def order_taxons_in_taxons_and_children(order)
-          order_taxons(order).where(id: taxons_including_children_ids)
-        end
-
-        def taxons_in_order_including_parents(order)
-          order_taxons_in_taxons_and_children(order).flat_map(&:self_and_ancestors).uniq
+        def rule_taxon_ids_with_children
+          taxons.flat_map { |taxon| taxon.self_and_descendants.ids }.uniq
         end
 
-        def taxon_product_ids
-          Spree::Product.joins(:taxons).where(spree_taxons: { id: taxons.pluck(:id) }).pluck(:id).uniq
-        end
       end
     end
   end

data/app/models/spree/promotion_action.rb

@@ -1,3 +1,5 @@
+require 'discard'
+
 module Spree
   # Base class for all types of promotion action.
   #
@@ -5,11 +7,15 @@ module Spree
   # 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
 
     belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions
 
     scope :of_type, ->(t) { where(type: Array.wrap(t).map(&:to_s)) }
-    scope :shipping, -> { of_type(Rails.application.config.spree.promotions.shipping_actions.to_a) }
+    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
     # the subclass options will contain the payload from the event that

data/app/models/spree/promotion_chooser.rb

@@ -12,7 +12,7 @@ module Spree
       if best_promotion_adjustment
         @adjustments.select(&:eligible?).each do |adjustment|
           next if adjustment == best_promotion_adjustment
-          adjustment.update_columns(eligible: false)
+          adjustment.update_columns(eligible: false, updated_at: Time.current)
         end
         best_promotion_adjustment.amount
       else

data/app/models/spree/promotion_code.rb

@@ -6,7 +6,7 @@ class Spree::PromotionCode < Spree::Base
   validates :value, presence: true, uniqueness: { allow_blank: true }
   validates :promotion, presence: true
 
-  before_save :downcase_value
+  before_save :normalize_code
 
   self.whitelisted_ransackable_attributes = ['value']
 
@@ -36,7 +36,7 @@ class Spree::PromotionCode < Spree::Base
 
   private
 
-  def downcase_value
-    self.value = value.downcase
+  def normalize_code
+    self.value = value.downcase.strip
   end
 end

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

@@ -1,15 +1,16 @@
 module Spree
   module PromotionHandler
     class Coupon
-      attr_reader :order
+      attr_reader :order, :coupon_code
       attr_accessor :error, :success, :status_code
 
       def initialize(order)
         @order = order
+        @coupon_code = order.coupon_code && order.coupon_code.downcase
       end
 
       def apply
-        if order.coupon_code.present?
+        if coupon_code.present?
           if promotion.present? && promotion.actions.exists?
             handle_present_promotion(promotion)
           elsif promotion_code && promotion_code.promotion.inactive?
@@ -24,12 +25,12 @@ module Spree
 
       def set_success_code(c)
         @status_code = c
-        @success = Spree.t(c)
+        @success = I18n.t(c, scope: 'spree')
       end
 
       def set_error_code(c)
         @status_code = c
-        @error = Spree.t(c)
+        @error = I18n.t(c, scope: 'spree')
       end
 
       def promotion
@@ -47,7 +48,7 @@ module Spree
       private
 
       def promotion_code
-        @promotion_code ||= Spree::PromotionCode.where(value: order.coupon_code.downcase).first
+        @promotion_code ||= Spree::PromotionCode.where(value: coupon_code).first
       end
 
       def handle_present_promotion(promotion)
@@ -62,7 +63,8 @@ module Spree
         # then result here will also be `true`.
         result = promotion.activate(order: order, promotion_code: promotion_code)
         if result
-          determine_promotion_application_result
+          order.recalculate
+          set_success_code :coupon_code_applied
         else
           set_error_code :coupon_code_unknown_error
         end
@@ -83,29 +85,6 @@ module Spree
       def promotion_exists_on_order?(order, promotion)
         order.promotions.include? promotion
       end
-
-      def determine_promotion_application_result
-        detector = lambda { |p|
-          p.source.promotion.codes.where(value: order.coupon_code.downcase).any?
-        }
-
-        # Check for applied adjustments.
-        discount = order.line_item_adjustments.promotion.detect(&detector)
-        discount ||= order.shipment_adjustments.promotion.detect(&detector)
-        discount ||= order.adjustments.promotion.detect(&detector)
-
-        if discount && discount.eligible
-          order.recalculate
-          set_success_code :coupon_code_applied
-        elsif order.promotions.with_coupon_code(order.coupon_code)
-          # if the promotion exists on an order, but wasn't found above,
-          # we've already selected a better promotion
-          set_error_code :coupon_code_better_exists
-        else
-          # if the promotion was created after the order
-          set_error_code :coupon_code_not_found
-        end
-      end
     end
   end
 end

data/app/models/spree/promotion_rule.rb

@@ -43,7 +43,7 @@ module Spree
     end
 
     def eligibility_error_message(key, options = {})
-      Spree.t(key, Hash[scope: [:eligibility_errors, :messages]].merge(options))
+      I18n.t(key, { scope: [:spree, :eligibility_errors, :messages] }.merge(options))
     end
   end
 end

data/app/models/spree/refund.rb

@@ -60,15 +60,15 @@ module Spree
       end
 
       if !response.success?
-        logger.error(Spree.t(:gateway_error) + "  #{response.to_yaml}")
+        logger.error(I18n.t('spree.gateway_error') + "  #{response.to_yaml}")
         text = response.params['message'] || response.params['response_reason_text'] || response.message
         raise Core::GatewayError.new(text)
       end
 
       response
     rescue ActiveMerchant::ConnectionError => e
-      logger.error(Spree.t(:gateway_error) + "  #{e.inspect}")
-      raise Core::GatewayError.new(Spree.t(:unable_to_connect_to_gateway))
+      logger.error(I18n.t('spree.gateway_error') + "  #{e.inspect}")
+      raise Core::GatewayError.new(I18n.t('spree.unable_to_connect_to_gateway'))
     end
 
     def create_log_entry

data/app/models/spree/reimbursement.rb

@@ -110,7 +110,7 @@ module Spree
       else
         errored!
         reimbursement_failure_hooks.each { |h| h.call self }
-        raise IncompleteReimbursementError, Spree.t("validation.unpaid_amount_not_zero", amount: unpaid_amount)
+        raise IncompleteReimbursementError, I18n.t("spree.validation.unpaid_amount_not_zero", amount: unpaid_amount)
       end
     end
 

data/app/models/spree/return_authorization.rb

@@ -64,7 +64,7 @@ module Spree
 
     def must_have_shipped_units
       if order.nil? || order.inventory_units.shipped.none?
-        errors.add(:order, Spree.t(:has_no_shipped_units))
+        errors.add(:order, I18n.t('spree.has_no_shipped_units'))
       end
     end
 
@@ -77,7 +77,7 @@ module Spree
 
     def no_previously_exchanged_inventory_units
       if return_items.map(&:inventory_unit).any?(&:exchange_requested?)
-        errors.add(:base, Spree.t(:return_items_cannot_be_created_for_inventory_units_that_are_already_awaiting_exchange))
+        errors.add(:base, I18n.t('spree.return_items_cannot_be_created_for_inventory_units_that_are_already_awaiting_exchange'))
       end
     end
 

data/app/models/spree/return_item.rb

@@ -184,7 +184,7 @@ module Spree
       # for pricing information for if the inventory unit is
       # ever returned. This means that the inventory unit's line_item
       # will have a different variant than the inventory unit itself
-      super(variant: exchange_variant, line_item: inventory_unit.line_item, order: inventory_unit.order) if exchange_required?
+      super(variant: exchange_variant, line_item: inventory_unit.line_item) if exchange_required?
     end
 
     # @return [Spree::Shipment, nil] the exchange inventory unit's shipment if it exists
@@ -262,14 +262,14 @@ module Spree
       return unless customer_return && inventory_unit
 
       if customer_return.order_id != inventory_unit.order_id
-        errors.add(:base, Spree.t(:return_items_cannot_be_associated_with_multiple_orders))
+        errors.add(:base, I18n.t('spree.return_items_cannot_be_associated_with_multiple_orders'))
       end
     end
 
     def eligible_exchange_variant
       return unless exchange_variant && exchange_variant_id_changed?
       unless eligible_exchange_variants.include?(exchange_variant)
-        errors.add(:base, Spree.t(:invalid_exchange_variant))
+        errors.add(:base, I18n.t('spree.invalid_exchange_variant'))
       end
     end
 

data/app/models/spree/return_item/eligibility_validator/base_validator.rb

@@ -10,11 +10,11 @@ module Spree
         end
 
         def eligible_for_return?
-          raise NotImplementedError, Spree.t(:implement_eligible_for_return)
+          raise NotImplementedError, I18n.t('spree.implement_eligible_for_return')
         end
 
         def requires_manual_intervention?
-          raise NotImplementedError, Spree.t(:implement_requires_manual_intervention)
+          raise NotImplementedError, I18n.t('spree.implement_requires_manual_intervention')
         end
 
         private

data/app/models/spree/return_item/eligibility_validator/inventory_shipped.rb

@@ -6,7 +6,7 @@ module Spree
           if @return_item.inventory_unit.shipped?
             return true
           else
-            add_error(:inventory_unit_shipped, Spree.t('return_item_inventory_unit_ineligible'))
+            add_error(:inventory_unit_shipped, I18n.t('spree.return_item_inventory_unit_ineligible'))
             return false
           end
         end

data/app/models/spree/return_item/eligibility_validator/no_reimbursements.rb

@@ -5,7 +5,7 @@ module Spree
 
         def eligible_for_return?
           if @return_item.inventory_unit.return_items.reimbursed.valid.any?
-            add_error(:inventory_unit_reimbursed, Spree.t('return_item_inventory_unit_reimbursed'))
+            add_error(:inventory_unit_reimbursed, I18n.t('spree.return_item_inventory_unit_reimbursed'))
             return false
           else
             return true