solidus_legacy_promotions 4.4.0

data/app/models/spree/promotion/order_adjustments_recalculator.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    # This class encapsulates all the things the promotion system does to
+    # an order. It is called from the `Spree::OrderUpdater` before taxes are
+    # calculated, such that taxes always respect promotions.
+
+    # This class iterates over all existing promotion adjustments and recalculates
+    # their amount and eligibility using their adjustment source.
+    class OrderAdjustmentsRecalculator
+      def initialize(order)
+        @order = order
+      end
+
+      def call
+        all_items = line_items + shipments
+        all_items.each do |item|
+          promotion_adjustments = item.adjustments.select(&:promotion?)
+
+          promotion_adjustments.each { |adjustment| recalculate(adjustment) }
+          Spree::Config.promotions.promotion_chooser_class.new(promotion_adjustments).update
+
+          item.promo_total = promotion_adjustments.select(&:eligible?).sum(&:amount)
+        end
+        # Update and select the best promotion adjustment for the order.
+        # We don't update the order.promo_total yet. Order totals are updated later
+        # in #update_adjustment_total since they include the totals from the order's
+        # line items and/or shipments.
+        order_promotion_adjustments = order.adjustments.select(&:promotion?)
+        order_promotion_adjustments.each { |adjustment| recalculate(adjustment) }
+        Spree::Config.promotions.promotion_chooser_class.new(order_promotion_adjustments).update
+
+        order.promo_total = all_items.sum(&:promo_total) +
+                            order_promotion_adjustments.
+                              select(&:eligible?).
+                              select(&:promotion?).
+                              sum(&:amount)
+        order
+      end
+
+      private
+
+      attr_reader :order
+
+      delegate :line_items, :shipments, to: :order
+
+      # Recalculate and persist the amount from this adjustment's source based on
+      # the adjustable ({Order}, {Shipment}, or {LineItem})
+      #
+      # If the adjustment has no source (such as when created manually from the
+      # admin) or is closed, this is a noop.
+      #
+      # @return [BigDecimal] New amount of this adjustment
+      def recalculate(adjustment)
+        if adjustment.finalized?
+          return adjustment.amount
+        end
+
+        # If the adjustment has no source, do not attempt to re-calculate the
+        # amount.
+        # Some scenarios where this happens:
+        #   - Adjustments that are manually created via the admin backend
+        #   - PromotionAction adjustments where the PromotionAction was deleted
+        #     after the order was completed.
+        if adjustment.source.present?
+          adjustment.amount = adjustment.source.compute_amount(adjustment.adjustable)
+
+          adjustment.eligible = calculate_eligibility(adjustment)
+
+          # Persist only if changed
+          # This is only not a save! to avoid the extra queries to load the order
+          # (for validations) and to touch the adjustment.
+          adjustment.update_columns(eligible: adjustment.eligible, amount: adjustment.amount, updated_at: Time.current) if adjustment.changed?
+        end
+        adjustment.amount
+      end
+
+      # Calculates based on attached promotion (if this is a promotion
+      # adjustment) whether this promotion is still eligible.
+      # @api private
+      # @return [true,false] Whether this adjustment is eligible
+      def calculate_eligibility(adjustment)
+        if !adjustment.finalized? && adjustment.source
+          adjustment.source.promotion.eligible?(adjustment.adjustable, promotion_code: adjustment.promotion_code)
+        else
+          adjustment.eligible?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    module Rules
+      class FirstOrder < PromotionRule
+        attr_reader :user, :email
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, options = {})
+          @user = order.try(:user) || options[:user]
+          @email = order.email
+
+          if (user || email) && (completed_orders.present? && completed_orders.first != order)
+            eligibility_errors.add(:base, eligibility_error_message(:not_first_order), error_code: :not_first_order)
+          end
+
+          eligibility_errors.empty?
+        end
+
+        private
+
+        def completed_orders
+          user ? user.orders.complete : orders_by_email
+        end
+
+        def orders_by_email
+          Spree::Order.where(email:).complete
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    module Rules
+      class FirstRepeatPurchaseSince < PromotionRule
+        preference :days_ago, :integer, default: 365
+        validates :preferred_days_ago, numericality: { only_integer: true, greater_than: 0 }
+
+        # This promotion is applicable to orders only.
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        # This is never eligible if the order does not have a user, and that user does not have any previous completed orders.
+        #
+        # This is eligible if the user's most recently completed order is more than the preferred days ago
+        # @param order [Spree::Order]
+        def eligible?(order, _options = {})
+          return false unless order.user
+
+          last_order = last_completed_order(order.user)
+          return false unless last_order
+
+          last_order.completed_at < preferred_days_ago.days.ago
+        end
+
+        private
+
+        def last_completed_order(user)
+          user.orders.complete.order(:completed_at).last
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    module Rules
+      # A rule to apply to an order greater than (or greater than or equal to)
+      # a specific amount
+      #
+      # To add extra operators please override `self.operators_map` or any other helper method.
+      # To customize the error message you can also override `ineligible_message`.
+      class ItemTotal < PromotionRule
+        preference :amount, :decimal, default: 100.00
+        preference :currency, :string, default: ->{ Spree::Config[:currency] }
+        preference :operator, :string, default: 'gt'
+
+        # The list of allowed operators names mapped to their symbols.
+        def self.operators_map
+          {
+            gte: :>=,
+            gt: :>,
+          }
+        end
+
+        def self.operator_options
+          operators_map.map do |name, _method|
+            [I18n.t(name, scope: 'spree.item_total_rule.operators'), name]
+          end
+        end
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, _options = {})
+          return false unless order.currency == preferred_currency
+
+          unless total_for_order(order).send(operator, threshold)
+            eligibility_errors.add(:base, ineligible_message, error_code: ineligible_error_code)
+          end
+
+          eligibility_errors.empty?
+        end
+
+        private
+
+        def operator
+          self.class.operators_map.fetch(
+            preferred_operator.to_sym,
+            preferred_operator_default,
+          )
+        end
+
+        def total_for_order(order)
+          order.item_total
+        end
+
+        def threshold
+          BigDecimal(preferred_amount.to_s)
+        end
+
+        def formatted_amount
+          Spree::Money.new(preferred_amount, currency: preferred_currency).to_s
+        end
+
+        def ineligible_message
+          case preferred_operator.to_s
+          when 'gte'
+            eligibility_error_message(:item_total_less_than, amount: formatted_amount)
+          when 'gt'
+            eligibility_error_message(:item_total_less_than_or_equal, amount: formatted_amount)
+          else
+            eligibility_error_message(:item_total_doesnt_match_with_operator, amount: formatted_amount, operator: preferred_operator)
+          end
+        end
+
+        def ineligible_error_code
+          if preferred_operator == 'gte'
+            :item_total_less_than
+          else
+            :item_total_less_than_or_equal
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion
+    module Rules
+      # Promotion rule for ensuring an order contains a minimum quantity of
+      # actionable items.
+      #
+      # This promotion rule is only compatible with the "all" match policy. It
+      # doesn't make a lot of sense to use it without that policy as it reduces
+      # it to a simple quantity check across the entire order which would be
+      # better served by an item total rule.
+      class MinimumQuantity < PromotionRule
+        validates :preferred_minimum_quantity, numericality: { only_integer: true, greater_than: 0 }
+
+        preference :minimum_quantity, :integer, default: 1
+
+        # What type of objects we should run our eligiblity checks against. In
+        # this case, our rule only applies to an entire order.
+        #
+        # @param promotable [Spree::Order,Spree::LineItem]
+        # @return [Boolean] true if promotable is a Spree::Order, false
+        #   otherwise
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        # Will look at all of the "actionable" line items in the order and
+        # determine if the sum of their quantity is greater than the minimum.
+        #
+        # "Actionable" items are ones where they pass the "actionable?" check of
+        # all rules on the promotion. (e.g.: Match product/taxon when one of
+        # those rules is present.)
+        #
+        # When false is returned, the reason will be included in the
+        # `eligibility_errors` object.
+        #
+        # @param order [Spree::Order] the order we want to check eligibility on
+        # @param _options [Hash] ignored
+        # @return [Boolean] true if promotion is eligible, false otherwise
+        def eligible?(order, _options = {})
+          actionable_line_items = order.line_items.select do |line_item|
+            promotion.rules.all? { _1.actionable?(line_item) }
+          end
+
+          if actionable_line_items.sum(&:quantity) < preferred_minimum_quantity
+            eligibility_errors.add(
+              :base,
+              eligibility_error_message(:quantity_less_than_minimum, count: preferred_minimum_quantity),
+              error_code: :quantity_less_than_minimum
+            )
+          end
+
+          eligibility_errors.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion
+    module Rules
+      class NthOrder < PromotionRule
+        preference :nth_order, :integer, default: 2
+        # It does not make sense to have this apply to the first order using preferred_nth_order == 1
+        # Instead we could use the first_order rule
+        validates :preferred_nth_order, numericality: { only_integer: true, greater_than: 1 }
+
+        # This promotion is applicable to orders only.
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        # This is never eligible if the order does not have a user, and that user does not have any previous completed orders.
+        #
+        # Use the first order rule if you want a promotion to be applied to the first order for a user.
+        # @param order [Spree::Order]
+        def eligible?(order, _options = {})
+          return false unless order.user
+
+          nth_order?(order)
+        end
+
+        private
+
+        def completed_order_count(order)
+          order.
+            user.
+            orders.
+            complete.
+            where(Spree::Order.arel_table[:completed_at].lt(order.completed_at || Time.current)).
+            count
+        end
+
+        def nth_order?(order)
+          count = completed_order_count(order) + 1
+          count == preferred_nth_order
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    module Rules
+      class OneUsePerUser < PromotionRule
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, _options = {})
+          if order.user.present?
+            if promotion.used_by?(order.user, [order])
+              eligibility_errors.add(:base, eligibility_error_message(:limit_once_per_user), error_code: :limit_once_per_user)
+            end
+          else
+            eligibility_errors.add(:base, eligibility_error_message(:no_user_specified), error_code: :no_user_specified)
+          end
+
+          eligibility_errors.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    module Rules
+      class OptionValue < PromotionRule
+        MATCH_POLICIES = %w(any)
+        preference :match_policy, :string, default: MATCH_POLICIES.first
+        preference :eligible_values, :hash
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(promotable, _options = {})
+          case preferred_match_policy
+          when 'any'
+            promotable.line_items.any? { |item| actionable?(item) }
+          end
+        end
+
+        def actionable?(line_item)
+          pid = line_item.product.id
+          ovids = line_item.variant.option_values.pluck(:id)
+
+          product_ids.include?(pid) && (value_ids(pid) & ovids).present?
+        end
+
+        def preferred_eligible_values
+          values = preferences[:eligible_values] || {}
+          Hash[values.keys.map(&:to_i).zip(
+            values.values.map do |value|
+              (value.is_a?(Array) ? value : value.split(",")).map(&:to_i)
+            end
+          )]
+        end
+
+        private
+
+        def product_ids
+          preferred_eligible_values.keys
+        end
+
+        def value_ids(product_id)
+          preferred_eligible_values[product_id]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    module Rules
+      # A rule to limit a promotion based on products in the order.  Can
+      # require all or any of the products to be present.  Valid products
+      # either come from assigned product group or are assingned directly to
+      # the rule.
+      class Product < PromotionRule
+        has_many :product_promotion_rules, dependent: :destroy, foreign_key: :promotion_rule_id,
+                                           class_name: 'Spree::ProductPromotionRule'
+        has_many :products, class_name: 'Spree::Product', through: :product_promotion_rules
+
+        def preload_relations
+          [:products]
+        end
+
+        MATCH_POLICIES = %w(any all none)
+
+        validates_inclusion_of :preferred_match_policy, in: MATCH_POLICIES
+
+        preference :match_policy, :string, default: MATCH_POLICIES.first
+
+        # scope/association that is used to test eligibility
+        def eligible_products
+          products
+        end
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, _options = {})
+          return true if eligible_products.empty?
+
+          case preferred_match_policy
+          when "all"
+            unless eligible_products.all? { |product| order_products(order).include?(product) }
+              eligibility_errors.add(:base, eligibility_error_message(:missing_product), error_code: :missing_product)
+            end
+          when "any"
+            unless order_products(order).any? { |product| eligible_products.include?(product) }
+              eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products),
+                                     error_code: :no_applicable_products)
+            end
+          when "none"
+            unless order_products(order).none? { |product| eligible_products.include?(product) }
+              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product),
+                                     error_code: :has_excluded_product)
+            end
+          else
+            raise "unexpected match policy: #{preferred_match_policy.inspect}"
+          end
+
+          eligibility_errors.empty?
+        end
+
+        def actionable?(line_item)
+          case preferred_match_policy
+          when 'any', 'all'
+            product_ids.include? line_item.variant.product_id
+          when 'none'
+            product_ids.exclude? line_item.variant.product_id
+          else
+            raise "unexpected match policy: #{preferred_match_policy.inspect}"
+          end
+        end
+
+        def product_ids_string
+          product_ids.join(',')
+        end
+
+        def product_ids_string=(product_ids)
+          self.product_ids = product_ids.to_s.split(',').map(&:strip)
+        end
+
+        private
+
+        def order_products(order)
+          order.line_items.map(&:variant).map(&:product)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion
+    module Rules
+      class Store < PromotionRule
+        has_many :promotion_rule_stores, class_name: "Spree::PromotionRuleStore",
+                                         foreign_key: :promotion_rule_id,
+                                         dependent: :destroy
+        has_many :stores, through: :promotion_rule_stores, class_name: "Spree::Store"
+
+        def preload_relations
+          [:stores]
+        end
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, _options = {})
+          stores.none? || stores.include?(order.store)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    module Rules
+      class Taxon < PromotionRule
+        has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', foreign_key: :promotion_rule_id,
+          dependent: :destroy
+        has_many :taxons, through: :promotion_rule_taxons, class_name: 'Spree::Taxon'
+
+        def preload_relations
+          [:taxons]
+        end
+
+        MATCH_POLICIES = %w(any all none)
+
+        validates_inclusion_of :preferred_match_policy, in: MATCH_POLICIES
+
+        preference :match_policy, :string, default: MATCH_POLICIES.first
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, _options = {})
+          order_taxons = taxons_in_order(order)
+
+          case preferred_match_policy
+          when 'all'
+            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), error_code: :missing_taxon)
+            end
+          when '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
+          when 'none'
+            if order_taxons.where(id: rule_taxon_ids_with_children).exists?
+              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_taxon), error_code: :has_excluded_taxon)
+            end
+          else
+            raise "unexpected match policy: #{preferred_match_policy.inspect}"
+          end
+
+          eligibility_errors.empty?
+        end
+
+        def actionable?(line_item)
+          found = Spree::Classification.where(
+            product_id: line_item.variant.product_id,
+            taxon_id: rule_taxon_ids_with_children
+          ).exists?
+
+          case preferred_match_policy
+          when 'any', 'all'
+            found
+          when 'none'
+            !found
+          else
+            raise "unexpected match policy: #{preferred_match_policy.inspect}"
+          end
+        end
+
+        def taxon_ids_string
+          taxons.pluck(:id).join(',')
+        end
+
+        def taxon_ids_string=(taxon_ids)
+          taxon_ids = taxon_ids.to_s.split(',').map(&:strip)
+          self.taxons = Spree::Taxon.find(taxon_ids)
+        end
+
+        private
+
+        # All taxons in an order
+        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 rule_taxon_ids_with_children
+          taxons.flat_map { |taxon| taxon.self_and_descendants.ids }.uniq
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    module Rules
+      class User < PromotionRule
+        has_many :promotion_rule_users, class_name: 'Spree::PromotionRuleUser',
+                                        foreign_key: :promotion_rule_id,
+                                        dependent: :destroy
+        has_many :users, through: :promotion_rule_users, class_name: Spree::UserClassHandle.new
+
+        def preload_relations
+          [:users]
+        end
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, _options = {})
+          users.include?(order.user)
+        end
+
+        def user_ids_string
+          user_ids.join(',')
+        end
+
+        def user_ids_string=(user_ids)
+          self.user_ids = user_ids.to_s.split(',').map(&:strip)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    module Rules
+      class UserLoggedIn < PromotionRule
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, _options = {})
+          if order.user.blank?
+            eligibility_errors.add(:base, eligibility_error_message(:no_user_specified), error_code: :no_user_specified)
+          end
+          eligibility_errors.empty?
+        end
+      end
+    end
+  end
+end