spree_core 6.0.0.beta4 → 6.0.0.rc2

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

@@ -87,6 +87,7 @@ module Spree
     # `name` is whitelisted so the admin global search / command palette can
     # filter via the `name_or_code_cont` predicate without a dedicated scope.
     self.whitelisted_ransackable_attributes = ['name', 'path', 'promotion_category_id', 'code', 'kind', 'starts_at', 'expires_at']
+    search_by :name, :code
     self.whitelisted_ransackable_associations = %w[coupon_codes]
 
     def self.with_coupon_code(coupon_code)
@@ -106,6 +107,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 +225,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 +263,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 +301,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 +348,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 +379,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
@@ -57,7 +58,9 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[number status currency reference expected_at
                                                  cancel_by ordered_at received_at closed_short_at
                                                  supplier_id destination_location_id created_at]
+    search_by :number, :reference
     self.whitelisted_ransackable_scopes = %w[open closed overdue past_cancel_by]
+    self.ransackable_scope_types = %w[open closed overdue past_cancel_by].index_with('boolean')
     self.whitelisted_ransackable_associations = %w[supplier destination_location items]
 
     # What the supplier will invoice for everything ordered.

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

@@ -5,6 +5,9 @@ module Spree
     include Spree::ActedBy
     include Spree::HasCustomFields
     include Spree::Metadata
+    include Spree::CanonicalDecimals
+
+    canonical_decimals :amount
     include Spree::InstrumentsGatewayCalls
     if defined?(Spree::Security::Refunds)
       include Spree::Security::Refunds
@@ -33,6 +36,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
@@ -42,10 +59,6 @@ module Spree
     # back through a payment that may belong to several orders.
     before_validation :assign_order_from_payment, on: :create
 
-    def amount=(amount)
-      self[:amount] = Spree::LocalizedNumber.parse(amount)
-    end
-
     def money
       Spree::Money.new(amount, currency: currency)
     end
@@ -76,6 +89,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
@@ -96,9 +120,7 @@ module Spree
     def perform!
       return true if transaction_id.present?
 
-      credit_cents = Spree::Money.new(amount.to_f, currency: currency).amount_in_cents
-
-      @response = process!(credit_cents)
+      @response = process!(payment.payment_method.gateway_amount(amount, currency))
 
       self.transaction_id = @response.authorization
       update_columns(transaction_id: transaction_id)
@@ -141,37 +163,38 @@ module Spree
     end
 
     # return a payment response object if successful or else raise an error
-    def process!(credit_cents)
-      refund_total_in_cents = calculate_refund_amount(credit_cents)
+    # @param credit_amount [Spree::Money, Integer] as PaymentMethod#gateway_amount returns it
+    def process!(credit_amount)
+      refund_total = calculate_refund_amount(credit_amount)
 
       response = instrument_gateway_call(:credit, payment.payment_method) do
         if payment.payment_method.payment_profiles_supported?
-          payment.payment_method.credit(refund_total_in_cents, payment.source, payment.transaction_id, originator: self)
+          payment.payment_method.credit(refund_total, payment.source, payment.transaction_id, originator: self)
         else
-          payment.payment_method.credit(refund_total_in_cents, payment.transaction_id, originator: self)
+          payment.payment_method.credit(refund_total, payment.transaction_id, originator: self)
         end
       end
 
       if response.success?
-        track_order_as_refunded(refund_total_in_cents)
+        track_order_as_refunded(refund_total)
       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)
+    def calculate_refund_amount(credit_amount)
       # Overwrite this for more complex calculations
-      credit_cents
+      credit_amount
     end
 
-    def track_order_as_refunded(credit_cents)
+    def track_order_as_refunded(credit_amount)
       # You can track refunds here
     end
 

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
@@ -51,6 +52,7 @@ module Spree
     delegate :currency, to: :order
 
     self.whitelisted_ransackable_attributes = %w[number status created_at]
+    search_by :number
     self.whitelisted_ransackable_associations = %w[order reason]
 
     # The label that currently binds the inbound parcel — bought or uploaded,
@@ -118,11 +120,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 +146,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 +178,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