spree_core 6.0.0.beta4 → 6.0.0.rc1

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

@@ -1,5 +1,5 @@
 # A rule to apply to an order greater than (or greater than or equal to)
-# a specific amount
+# a specific amount. Free gifts do not count toward it.
 module Spree
   class Promotion
     module Rules
@@ -12,12 +12,8 @@ module Spree
         OPERATORS_MIN = ['gt', 'gte']
         OPERATORS_MAX = ['lt', 'lte']
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
-        def eligible?(order, _options = {})
-          item_total = order.item_total
+        def eligible?(order, options = {})
+          item_total = order.item_total - order.gift_amount(promotion: promotion, own_gift_only: options.fetch(:own_gift_only, false))
 
           lower_limit_condition = item_total.send(preferred_operator_min == 'gte' ? :>= : :>, BigDecimal(preferred_amount_min.to_s))
 
@@ -43,7 +39,7 @@ module Spree
           if preferred_amount_max.present?
             Spree::Money.new(preferred_amount_max, currency: order.currency).to_s
           else
-            Spree.t('no_maximum')
+            I18n.t('spree.no_maximum')
           end
         end
 

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

@@ -14,10 +14,6 @@ module Spree
                      scope: ->(rule) { rule.promotion.store.markets }
                    )
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def markets
           return Spree::Market.none if preferred_market_ids.blank?
 

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

@@ -2,10 +2,6 @@ module Spree
   class Promotion
     module Rules
       class OneUsePerUser < Spree::PromotionRule
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def eligible?(order, _options = {})
           if order.customer.present?
             if promotion.used_by?(order.customer, [order])

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

@@ -13,9 +13,6 @@ module Spree
 
         # @param promotable [Object]
         # @return [Boolean]
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
 
         # @return [ActiveRecord::Relation<Spree::OptionValue>]
         def option_values

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

@@ -49,10 +49,6 @@ module Spree
           @eligible_product_ids ||= product_promotion_rules.pluck(:product_id)
         end
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def eligible?(order, _options = {})
           return true if eligible_product_ids.empty?
 

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

@@ -33,10 +33,6 @@ module Spree
         #
         after_save :add_users
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def eligible_user_ids
           @eligible_user_ids ||= promotion_rule_users.pluck(:customer_id)
         end

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

@@ -8,10 +8,6 @@ module Spree
           'customer_logged_in'
         end
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def eligible?(order, _options = {})
           unless order.customer.present?
             eligibility_errors.add(:base, eligibility_error_message(:no_user_specified))

data/app/models/spree/promotion.rb

@@ -106,6 +106,28 @@ module Spree
         where('spree_promotions.expires_at IS NULL OR spree_promotions.expires_at > ?', Time.current)
     end
 
+    # The promotion a purchase's PERSISTED coupon code names, which keeps it in
+    # candidacy even before it ever applied — the discount activates on the
+    # exact recalculation where the cart first qualifies, and deactivates the
+    # same way (Shopify-parity for cart-level discount codes). In-memory
+    # assignments deliberately don't participate: unsaved codes belong to
+    # the explicit PromotionHandler::Coupon path. A batch code counts only
+    # while the purchase holds it (see #eligible?).
+    #
+    # @param purchase [Spree::Cart, Spree::Order]
+    # @return [Array<Spree::Promotion>] empty, or the one promotion
+    def self.held_by_saved_coupon_code(purchase)
+      return [] unless purchase.class.respond_to?(:column_names) && purchase.class.column_names.include?('coupon_code')
+
+      code = purchase.read_attribute(:coupon_code)
+      return [] if code.blank?
+
+      promotion = purchase.store.promotions.active.with_coupon_code(code)
+      return [] if promotion.nil? || promotion.usage_limit_exceeded?(purchase)
+
+      [promotion]
+    end
+
     def self.order_activatable?(promotable)
       # Carts have no cancellation concept — only placed orders can be canceled.
       promotable && !promotable.completed? && !(promotable.is_a?(Spree::Order) && promotable.canceled?)
@@ -202,7 +224,7 @@ module Spree
 
     # called anytime order.recalculate_totals! happens
     def eligible?(promotable, options = {})
-      return false if expired? || usage_limit_exceeded?(promotable) || blacklisted?(promotable)
+      return false if expired? || usage_limit_exceeded?(promotable) || blacklisted?(promotable) || !code_held_by?(promotable)
 
       !!eligible_rules(promotable, options)
     end
@@ -240,7 +262,7 @@ module Spree
     end
 
     def products
-      rules.where(type: %w[Spree::Promotion::Rules::Product Spree::Promotion::Rules::Product]).map(&:products).flatten.uniq
+      rules.where(type: 'Spree::Promotion::Rules::Product').map(&:products).flatten.uniq
     end
 
     def usage_limit_exceeded?(promotable)
@@ -278,9 +300,9 @@ module Spree
       checkouts_credited(credits)
     end
 
-    def line_item_actionable?(order, line_item)
-      if eligible? order
-        rules = eligible_rules(order)
+    def line_item_actionable?(order, line_item, options = {})
+      if eligible?(order, options)
+        rules = eligible_rules(order, options)
         if rules.blank?
           true
         else
@@ -325,6 +347,13 @@ module Spree
 
     private
 
+    # A batch code discounts only the cart or order holding it, which is what
+    # keeps each generated code to a single order. A cart's line item has no
+    # order, and the adjuster has asked with the cart before pricing its lines.
+    def code_held_by?(order)
+      !multi_codes? || order.nil? || coupon_codes.held_by(order).exists?
+    end
+
     # Counts distinct checkouts behind a set of discount rows.
     #
     # An order placed on its own is one checkout; the several orders a split
@@ -349,7 +378,7 @@ module Spree
     def not_used?
       return true if orders.empty?
 
-      errors.add(:base, :promotion_already_used, message: Spree.t('promotion_already_used'))
+      errors.add(:base, :promotion_already_used, message: I18n.t('spree.promotion_already_used'))
       throw(:abort)
     end
 

data/app/models/spree/promotion_action.rb

@@ -2,6 +2,10 @@
 # PromotionActions perform the necessary tasks when a promotion is activated by an event and determined to be eligible.
 module Spree
   class PromotionAction < Spree.base_class
+    include Spree::TypeLabels
+
+    self.type_labels_scope = 'spree.promotion_action_types'
+
     has_prefix_id :pact
 
     registers_subclasses_via { Spree.promotions.actions }
@@ -66,25 +70,14 @@ module Spree
       when :line_item
         %w[Spree::Promotion::Actions::CreateItemAdjustments Spree::Promotion::Actions::CreateLineItems]
       when :fulfillment
-        %w[Spree::Promotion::Actions::FreeShipping Spree::Promotion::Actions::FreeShipping]
+        %w[Spree::Promotion::Actions::FreeShipping]
       when :order
-        %w[Spree::Promotion::Actions::CreateAdjustment Spree::Promotion::Actions::CreateAdjustment]
+        %w[Spree::Promotion::Actions::CreateAdjustment]
       else
         []
       end
     end
 
-    def self.human_name
-      Spree.t("promotion_action_types.#{api_type}.name", default: api_type.titleize)
-    end
-
-    def self.human_description
-      Spree.t("promotion_action_types.#{api_type}.description", default: '')
-    end
-
-    def human_name = self.class.human_name
-    def human_description = self.class.human_description
-
     # Returns the key of the promotion action
     #
     # @return [String] eg. free_shipping
@@ -109,7 +102,7 @@ module Spree
     end
 
     def label
-      Spree.t(:promotion_label, name: promotion.name)
+      I18n.t('spree.promotion_label', name: promotion.name)
     end
   end
 end

data/app/models/spree/promotion_action_line_item.rb

@@ -4,6 +4,6 @@ module Spree
     belongs_to :variant, class_name: 'Spree::Variant'
 
     validates :quantity, presence: true
-    validates :quantity, numericality: { only_integer: true, message: Spree.t('validation.must_be_int') }
+    validates :quantity, numericality: { only_integer: true, message: I18n.t('spree.validation.must_be_int') }
   end
 end

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

@@ -39,7 +39,7 @@ module Spree
               @status_code = :gift_card_not_applied
               # The rejection message is what the hook author wrote for the
               # shopper; fall back to the generic string if it says nothing.
-              @error = result.error.to_s.presence || Spree.t(:gift_card_not_applied)
+              @error = result.error.to_s.presence || I18n.t('spree.gift_card_not_applied')
             end
           end
 
@@ -57,9 +57,25 @@ module Spree
         else
           set_error_code :coupon_code_not_found
         end
+        release_stale_coupon_codes
         self
       end
 
+      # Gives back every batch code this cart or order holds but no longer
+      # shows: anything other than the code it entered while that code waits
+      # to qualify, or the codes of promotions attached to it. Without this a
+      # replaced or dropped code stays held, and is spent with the order.
+      #
+      # @return [void]
+      def release_stale_coupon_codes
+        return unless order.persisted?
+
+        stale = Spree::CouponCode.unused.held_by(order).where.not(promotion_id: order.promotions.select(:id))
+        pending = order.coupon_code.to_s.downcase.presence if status_code == :coupon_code_not_eligible
+        stale = stale.where.not(code: pending) if pending
+        stale.find_each(&:remove_from_order)
+      end
+
       def remove(coupon_code)
         if gift_cards_enabled? && order.gift_card
           result = order.remove_gift_card
@@ -75,19 +91,13 @@ module Spree
 
         promotion = order.promotions.with_coupon_code(coupon_code)
         if promotion.present?
-          # Order promotion has to be destroyed before line item removing
-          order.promotions.delete(promotion)
           clear_persisted_coupon_code(coupon_code)
+          detach_promotion(promotion)
 
-          if promotion.multi_codes?
-            promotion.coupon_codes.held_by(order).first&.remove_from_order
-          else
-            promotion.touch
-          end
-
-          remove_promotion_adjustments(promotion)
-          remove_promotion_line_items(promotion)
-          order.recalculate_totals!
+          set_success_code :adjustments_deleted
+        elsif clear_persisted_coupon_code(coupon_code)
+          # Saved before the cart qualified, so no promotion is attached yet.
+          Spree::CouponCode.held_by(order).find_by(code: coupon_code.to_s.strip.downcase)&.remove_from_order
 
           set_success_code :adjustments_deleted
         else
@@ -96,14 +106,26 @@ module Spree
         self
       end
 
+      # Gives the code up to another cart or order that has taken it. Unlike
+      # #remove, the entered code stays on this one, so the shopper can be
+      # told it went (Spree::Cart#remove_unavailable_coupon_code!).
+      #
+      # @param coupon_code [String]
+      # @return [self]
+      def release(coupon_code)
+        promotion = order.promotions.with_coupon_code(coupon_code)
+        detach_promotion(promotion) if promotion.present?
+        self
+      end
+
       def set_success_code(code)
         @status_code = code
-        @success = Spree.t(code)
+        @success = I18n.t("spree.#{code}")
       end
 
       def set_error_code(code, locale_options = {})
         @status_code = code
-        @error = Spree.t(code, locale_options)
+        @error = I18n.t("spree.#{code}", **locale_options)
       end
 
       # Returns the promotion for the order
@@ -143,6 +165,21 @@ module Spree
         order.update_column(:coupon_code, nil)
       end
 
+      def detach_promotion(promotion)
+        # Order promotion has to be destroyed before line item removing
+        order.promotions.delete(promotion)
+
+        if promotion.multi_codes?
+          promotion.coupon_codes.held_by(order).first&.remove_from_order
+        else
+          promotion.touch
+        end
+
+        remove_promotion_adjustments(promotion)
+        remove_promotion_line_items(promotion)
+        order.recalculate_totals!
+      end
+
       def remove_promotion_adjustments(promotion)
         order.discounts.where(promotion_action_id: promotion.actions.pluck(:id)).destroy_all
       end
@@ -165,6 +202,11 @@ module Spree
         return set_error_code :coupon_code_used if promotion.coupon_codes.used.where(code: order.coupon_code).exists?
         return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded?(order)
 
+        # Claimed before anything prices the code, since the adjuster only
+        # discounts the holder, and a cart that qualifies later activates the
+        # code on recalculation without coming back here.
+        return set_error_code :coupon_code_used unless claim_coupon_code(order.coupon_code.downcase)
+
         unless promotion.eligible?(order, options)
           # Rules that explain themselves keep their message, but the status
           # code is always :coupon_code_not_eligible so callers can park the
@@ -216,11 +258,6 @@ module Spree
         end
 
         if discount || created_line_items
-          if discount && !claim_coupon_code(discount, coupon_code)
-            release_coupon_code(order, coupon_code)
-            return set_error_code :coupon_code_used
-          end
-
           order.recalculate_totals!
           set_success_code :coupon_code_applied
         elsif order.promotions.with_coupon_code(order.coupon_code)
@@ -249,8 +286,8 @@ module Spree
       # them in, so the two serialize instead of deadlocking.
       #
       # @return [Boolean] false when the code can no longer be claimed
-      def claim_coupon_code(discount, coupon_code)
-        record = Spree::CouponCode.find_by(promotion_id: discount.promotion_id, code: coupon_code)
+      def claim_coupon_code(coupon_code)
+        record = promotion.coupon_codes.find_by(code: coupon_code)
         return true if record.nil?
 
         holder = record.holder
@@ -261,16 +298,11 @@ module Spree
           record.lock!
           next false if record.used? || !same_holder?(record.holder, holder) || !releasable?(holder)
 
-          release_coupon_code(holder, coupon_code) if holder
+          self.class.new(holder).release(coupon_code) if holder
           record.apply_order!(order)
         end
       end
 
-      # Gift cards are turned off so a holder paying with one keeps it.
-      def release_coupon_code(holder, coupon_code)
-        self.class.new(holder, enable_gift_cards: false).remove(coupon_code)
-      end
-
       def releasable?(holder)
         return true if holder.nil?
 

data/app/models/spree/promotion_rule.rb

@@ -1,6 +1,10 @@
 # Base class for all promotion rules
 module Spree
   class PromotionRule < Spree.base_class
+    include Spree::TypeLabels
+
+    self.type_labels_scope = 'spree.promotion_rule_types'
+
     has_prefix_id :prorule
 
     registers_subclasses_via { Spree.promotions.rules }
@@ -17,8 +21,8 @@ module Spree
       all.select { |rule| rule.applicable?(promotable) }
     end
 
-    def applicable?(_promotable)
-      raise 'applicable? should be implemented in a sub-class of Spree::PromotionRule'
+    def applicable?(promotable)
+      promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
     end
 
     def eligible?(_promotable, _options = {})
@@ -35,17 +39,6 @@ module Spree
       @eligibility_errors ||= ActiveModel::Errors.new(self)
     end
 
-    def self.human_name
-      Spree.t("promotion_rule_types.#{api_type}.name", default: api_type.titleize)
-    end
-
-    def self.human_description
-      Spree.t("promotion_rule_types.#{api_type}.description", default: '')
-    end
-
-    def human_name = self.class.human_name
-    def human_description = self.class.human_description
-
     # Returns the key of the promotion rule
     #
     # @return [String] eg. currency
@@ -70,7 +63,7 @@ module Spree
     end
 
     def eligibility_error_message(key, options = {})
-      Spree.t(key, Hash[scope: [:eligibility_errors, :messages]].merge(options))
+      I18n.t("spree.eligibility_errors.messages.#{key}", **options)
     end
   end
 end

data/app/models/spree/purchase_order.rb

@@ -26,6 +26,7 @@ module Spree
     include Spree::Metadata
 
     publishes_lifecycle_events
+    publishes_events :canceled, :draft, :ordered, :partially_received, :over_received, :received
 
     has_status :draft, :ordered, :partially_received, :received, :over_received, :canceled,
                default: :draft

data/app/models/spree/quantity_rule.rb

@@ -83,7 +83,7 @@ module Spree
     def violation_message(name, quantity)
       return nil if satisfied_by?(quantity)
 
-      Spree.t('cart_line_item.quantity_rule_violated',
+      I18n.t('spree.cart_line_item.quantity_rule_violated',
               li_name: name, quantities: nearest_valid(quantity).to_sentence)
     end
 

data/app/models/spree/refund.rb

@@ -33,6 +33,20 @@ module Spree
     validate :amount_is_less_than_or_equal_to_allowed_amount, on: :create, if: :amount
     validate :order_is_covered_by_payment, on: :create
 
+    # Refunds for goods that came back, which settle what the customer owed
+    # for them rather than leaving it owed again.
+    scope :for_returned_items, -> { where(originator_type: returned_item_originators) }
+
+    # @return [Array<String>]
+    def self.returned_item_originators
+      [Spree::Return, Spree::Claim, Spree::Exchange].map(&:polymorphic_name)
+    end
+
+    # @return [Boolean]
+    def for_returned_items?
+      self.class.returned_item_originators.include?(originator_type)
+    end
+
     attr_reader :response
 
     delegate :currency, to: :payment
@@ -76,6 +90,17 @@ module Spree
       originator.refunded_line_amounts
     end
 
+    # The tax inside {#refunded_line_amounts}, for the lines whose tax is known.
+    # A line opened before returns and claims carried tax is absent: its amount
+    # says nothing about how much of it was tax.
+    #
+    # @return [Hash{Integer => BigDecimal}] line item id => tax
+    def refunded_line_taxes
+      return {} unless originator.respond_to?(:refunded_line_taxes)
+
+      originator.refunded_line_taxes
+    end
+
     # Returns true if the refund is editable.
     #
     # Read through the refund's own order: a payment shared by a split checkout
@@ -155,15 +180,15 @@ module Spree
       if response.success?
         track_order_as_refunded(refund_total_in_cents)
       else
-        Rails.logger.error(Spree.t(:gateway_error) + "  #{response.to_yaml}")
+        Rails.logger.error(I18n.t('spree.gateway_error') + "  #{response.to_yaml}")
         text = response.params['message'] || response.params['response_reason_text'] || response.message
         raise Core::GatewayError, text
       end
 
       response
     rescue Spree::PaymentConnectionError => e
-      Rails.logger.error(Spree.t(:gateway_error) + "  #{e.inspect}")
-      raise Core::GatewayError, Spree.t(:unable_to_connect_to_gateway)
+      Rails.logger.error(I18n.t('spree.gateway_error') + "  #{e.inspect}")
+      raise Core::GatewayError, I18n.t('spree.unable_to_connect_to_gateway')
     end
 
     def calculate_refund_amount(credit_cents)

data/app/models/spree/return.rb

@@ -20,13 +20,14 @@ module Spree
     include Spree::HasStatus
     include Spree::HasCustomFields
     include Spree::Metadata
+    include Spree::PostSale::Taxation
 
     publishes_lifecycle_events
+    publishes_events :approved, :canceled, :received, :refunded, :requested
 
     has_status :requested, :approved, :received, :refunded, :canceled,
                default: :requested
 
-    belongs_to :store, class_name: 'Spree::Store'
     belongs_to :order, class_name: 'Spree::Order', inverse_of: :returns
     belongs_to :stock_location, class_name: 'Spree::StockLocation'
     belongs_to :reason, class_name: 'Spree::ReturnReason', optional: true, inverse_of: :returns
@@ -118,11 +119,16 @@ module Spree
       received? || refunded?
     end
 
-    # What the customer is owed for the items being returned.
+    # What the customer is owed for the items being returned, tax included.
     def refund_total
       return_line_items.sum(&:refund_amount)
     end
 
+    # The tax inside {#refund_total}.
+    def refund_tax_total
+      return_line_items.sum(&:refund_tax_amount)
+    end
+
     # What a refund from this return paid for, line by line. Only ever what
     # the warehouse counted: the seller's clawback is built from this, and a
     # line nobody counted earned nothing back.
@@ -139,6 +145,20 @@ module Spree
       end
     end
 
+    # The tax inside {#refunded_line_amounts}, for the lines whose tax is
+    # recorded.
+    #
+    # @return [Hash{Integer => BigDecimal}] line item id => tax
+    def refunded_line_taxes
+      return {} unless counted?
+
+      return_line_items.each_with_object(Hash.new(0)) do |line, taxes|
+        next if line.refund_amount.zero? || !line.settles_tax?
+
+        taxes[line.line_item_id] += line.refund_tax_amount
+      end
+    end
+
     # What has actually been refunded so far — a return can be refunded in
     # more than one step (part to store credit, part to the card), and store
     # credit is its own ledger rather than a Spree::Refund row.
@@ -157,5 +177,13 @@ module Spree
     def display_refunded_total
       Spree::Money.new(refunded_total, currency: currency)
     end
+
+    def display_refund_tax_total
+      Spree::Money.new(refund_tax_total, currency: currency)
+    end
+
+    def taxed_lines
+      return_line_items
+    end
   end
 end