solidus_promotions 4.4.0

data/app/models/solidus_promotions/conditions/line_item_taxon.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class LineItemTaxon < Condition
+      include LineItemLevelCondition
+
+      has_many :condition_taxons, class_name: "SolidusPromotions::ConditionTaxon", foreign_key: :condition_id,
+        dependent: :destroy
+      has_many :taxons, through: :condition_taxons, class_name: "Spree::Taxon"
+
+      MATCH_POLICIES = %w[include exclude].freeze
+
+      validates :preferred_match_policy, inclusion: { in: MATCH_POLICIES }
+
+      preference :match_policy, :string, default: MATCH_POLICIES.first
+
+      def preload_relations
+        [:taxons]
+      end
+
+      def eligible?(line_item, _options = {})
+        found = Spree::Classification.where(
+          product_id: line_item.variant.product_id,
+          taxon_id: condition_taxon_ids_with_children
+        ).exists?
+
+        case preferred_match_policy
+        when "include"
+          found
+        when "exclude"
+          !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
+
+      def updateable?
+        true
+      end
+
+      private
+
+      # ids of taxons conditions and taxons conditions children
+      def condition_taxon_ids_with_children
+        taxons.flat_map { |taxon| taxon.self_and_descendants.ids }.uniq
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/minimum_quantity.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    # Promotion condition for ensuring an order contains a minimum quantity of
+    # applicable items.
+    #
+    # This promotion condition 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 condition.
+    class MinimumQuantity < Condition
+      include OrderLevelCondition
+
+      validates :preferred_minimum_quantity, numericality: { only_integer: true, greater_than: 0 }
+
+      preference :minimum_quantity, :integer, default: 1
+
+      # Will look at all of the "applicable" line items in the order and
+      # determine if the sum of their quantity is greater than the minimum.
+      #
+      # "Applicable" items are ones that pass all eligibility checks of applicable conditions.
+      #
+      # 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
+      # @return [Boolean] true if promotion is eligible, false otherwise
+      def eligible?(order)
+        if benefit.applicable_line_items(order).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

data/app/models/solidus_promotions/conditions/nth_order.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class NthOrder < Condition
+      include OrderLevelCondition
+
+      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 condition
+      validates :preferred_nth_order, numericality: { only_integer: true, greater_than: 1 }
+
+      # 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 condition 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

data/app/models/solidus_promotions/conditions/one_use_per_user.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class OneUsePerUser < Condition
+      include OrderLevelCondition
+
+      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

data/app/models/solidus_promotions/conditions/option_value.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class OptionValue < Condition
+      include LineItemApplicableOrderLevelCondition
+
+      preference :eligible_values, :hash
+
+      def order_eligible?(order)
+        order.line_items.any? { |item| line_item_eligible?(item) }
+      end
+
+      def line_item_eligible?(line_item)
+        LineItemOptionValue.new(preferred_eligible_values: preferred_eligible_values).eligible?(line_item)
+      end
+
+      def preferred_eligible_values
+        values = preferences[:eligible_values] || {}
+        values.keys.map(&:to_i).zip(
+          values.values.map do |value|
+            (value.is_a?(Array) ? value : value.split(",")).map(&:to_i)
+          end
+        ).to_h
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/product.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    # A condition 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 condition.
+    class Product < Condition
+      include LineItemApplicableOrderLevelCondition
+
+      has_many :condition_products,
+        dependent: :destroy,
+        foreign_key: :condition_id,
+        class_name: "SolidusPromotions::ConditionProduct"
+      has_many :products, class_name: "Spree::Product", through: :condition_products
+
+      def preload_relations
+        [:products]
+      end
+
+      MATCH_POLICIES = %w[any all none only].freeze
+
+      validates :preferred_match_policy, inclusion: { 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 order_eligible?(order)
+        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
+        when "only"
+          unless order_products(order).all? { |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 line_item_eligible?(line_item, _options = {})
+        # The order level eligibility check happens first, and if none of the products
+        # are in the order, then no line items should be available to check.
+        raise "This should not happen" if preferred_match_policy == "none"
+        product_ids.include?(line_item.variant.product_id)
+      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

data/app/models/solidus_promotions/conditions/shipping_method.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class ShippingMethod < Condition
+      include ShipmentLevelCondition
+
+      preference :shipping_method_ids, type: :array, default: []
+
+      def applicable?(promotable)
+        promotable.is_a?(Spree::Shipment) || promotable.is_a?(Spree::ShippingRate)
+      end
+
+      def eligible?(promotable)
+        promotable.shipping_method&.id&.in?(preferred_shipping_method_ids.map(&:to_i))
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/store.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class Store < Condition
+      include OrderLevelCondition
+
+      has_many :condition_stores, class_name: "SolidusPromotions::ConditionStore",
+        foreign_key: :condition_id,
+        dependent: :destroy
+      has_many :stores, through: :condition_stores, class_name: "Spree::Store"
+
+      def preload_relations
+        [:stores]
+      end
+
+      def eligible?(order, _options = {})
+        stores.none? || stores.include?(order.store)
+      end
+
+      def updateable?
+        true
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/taxon.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class Taxon < Condition
+      include LineItemApplicableOrderLevelCondition
+
+      has_many :condition_taxons, class_name: "SolidusPromotions::ConditionTaxon", foreign_key: :condition_id,
+        dependent: :destroy
+      has_many :taxons, through: :condition_taxons, class_name: "Spree::Taxon"
+
+      def preload_relations
+        [:taxons]
+      end
+
+      MATCH_POLICIES = %w[any all none].freeze
+
+      validates :preferred_match_policy, inclusion: { in: MATCH_POLICIES }
+
+      preference :match_policy, :string, default: MATCH_POLICIES.first
+
+      def order_eligible?(order)
+        order_taxons = taxons_in_order(order)
+
+        case preferred_match_policy
+        when "all"
+          matches_all = taxons.all? do |condition_taxon|
+            order_taxons.where(id: condition_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: condition_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: condition_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 line_item_eligible?(line_item)
+        # The order level eligibility check happens first, and if none of the taxons
+        # are in the order, then no line items should be available to check.
+        raise "This should not happen" if preferred_match_policy == "none"
+
+        raise "unexpected match policy: #{preferred_match_policy.inspect}" unless preferred_match_policy.in?(MATCH_POLICIES)
+
+        Spree::Classification.where(
+          product_id: line_item.variant.product_id,
+          taxon_id: condition_taxon_ids_with_children
+        ).exists?
+      end
+
+      def taxon_ids_string
+        taxon_ids.join(",")
+      end
+
+      def taxon_ids_string=(taxon_ids)
+        self.taxon_ids = taxon_ids.to_s.split(",").map(&:strip)
+      end
+
+      def updateable?
+        true
+      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 conditions and taxons conditions children
+      def condition_taxon_ids_with_children
+        taxons.flat_map { |taxon| taxon.self_and_descendants.ids }.uniq
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/user.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class User < Condition
+      include OrderLevelCondition
+
+      has_many :condition_users,
+        class_name: "SolidusPromotions::ConditionUser",
+        foreign_key: :condition_id,
+        dependent: :destroy
+      has_many :users, through: :condition_users, class_name: Spree::UserClassHandle.new
+
+      def preload_relations
+        [:users]
+      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
+
+      def updateable?
+        true
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/user_logged_in.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class UserLoggedIn < Condition
+      include OrderLevelCondition
+
+      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

data/app/models/solidus_promotions/conditions/user_role.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class UserRole < Condition
+      include OrderLevelCondition
+
+      preference :role_ids, :array, default: []
+
+      MATCH_POLICIES = %w[any all].freeze
+      preference :match_policy, default: MATCH_POLICIES.first
+
+      def eligible?(order, _options = {})
+        return false unless order.user
+
+        if all_match_policy?
+          match_all_roles?(order)
+        else
+          match_any_roles?(order)
+        end
+      end
+
+      private
+
+      def all_match_policy?
+        preferred_match_policy == "all" && preferred_role_ids.present?
+      end
+
+      def user_roles(order)
+        order.user.spree_roles.where(id: preferred_role_ids)
+      end
+
+      def match_all_roles?(order)
+        user_roles(order).count == preferred_role_ids.count
+      end
+
+      def match_any_roles?(order)
+        user_roles(order).exists?
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/distributed_amounts_handler.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class DistributedAmountsHandler
+    attr_reader :line_items, :total_amount
+
+    def initialize(line_items, total_amount)
+      @line_items = line_items
+      @total_amount = total_amount
+    end
+
+    # @param line_item [LineItem] one of the line_items distributed over
+    # @return [BigDecimal] the weighted adjustment for this line_item
+    def amount(line_item)
+      distributed_amounts[line_item.id].to_d
+    end
+
+    private
+
+    # @private
+    # @return [Hash<Integer, BigDecimal>] a hash of line item IDs and their
+    #   corresponding weighted adjustments
+    def distributed_amounts
+      line_item_ids.zip(allocated_amounts).to_h
+    end
+
+    def line_item_ids
+      line_items.map(&:id)
+    end
+
+    def elligible_amounts
+      line_items.map(&:discountable_amount)
+    end
+
+    def allocated_amounts
+      total_amount.to_money.allocate(elligible_amounts).map(&:to_money)
+    end
+  end
+end

data/app/models/solidus_promotions/eligibility_result.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  EligibilityResult = Struct.new(:item, :condition, :success, :code, :message, keyword_init: true)
+end

data/app/models/solidus_promotions/eligibility_results.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class EligibilityResults
+    include Enumerable
+    attr_reader :results, :promotion
+
+    def initialize(promotion)
+      @promotion = promotion
+      @results = []
+    end
+
+    def add(item:, condition:, success:, code:, message:)
+      results << EligibilityResult.new(
+        item: item,
+        condition: condition,
+        success: success,
+        code: code,
+        message: message
+      )
+    end
+
+    def success?
+      return true if results.empty?
+      promotion.benefits.any? do |benefit|
+        benefit.conditions.all? do |condition|
+          results_for_condition = results.select { |result| result.condition == condition }
+          results_for_condition.any?(&:success)
+        end
+      end
+    end
+
+    def error_messages
+      return [] if results.empty?
+      results.group_by(&:condition).map do |_condition, results|
+        next if results.any?(&:success)
+        results.detect { |r| !r.success }&.message
+      end.compact
+    end
+
+    def each(&block)
+      results.each(&block)
+    end
+
+    delegate :last, to: :results
+  end
+end

data/app/models/solidus_promotions/item_discount.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  # Simple object used to hold discount data for an item.
+  #
+  # This generic object will hold the amount of discount that should be applied to
+  # an item.
+  #
+  # @attr_reader [Spree::LineItem,Spree::Shipment] the item to be discounted.
+  # @attr_reader [String] label information about the discount
+  # @attr_reader [ApplicationRecord] source will be used as the source for adjustments
+  # @attr_reader [BigDecimal] amount the amount of discount applied to the item
+  class ItemDiscount
+    include ActiveModel::Model
+    attr_accessor :item, :label, :source, :amount
+
+    def ==(other)
+      item == other.item && label == other.label && source == other.source && amount == other.amount
+    end
+  end
+end