solidus_legacy_promotions 4.4.0

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    module Rules
+      class UserRole < PromotionRule
+        preference :role_ids, :array, default: []
+
+        MATCH_POLICIES = %w(any all)
+        preference :match_policy, default: MATCH_POLICIES.first
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        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
+end

data/app/models/spree/promotion.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    UNACTIVATABLE_ORDER_STATES = ["complete", "awaiting_return", "returned"]
+
+    attr_reader :eligibility_errors
+
+    belongs_to :promotion_category, optional: true
+
+    has_many :promotion_rules, autosave: true, dependent: :destroy, inverse_of: :promotion
+    alias_method :rules, :promotion_rules
+
+    has_many :promotion_actions, autosave: true, dependent: :destroy, inverse_of: :promotion
+    alias_method :actions, :promotion_actions
+
+    has_many :order_promotions, class_name: "Spree::OrderPromotion", inverse_of: :promotion, dependent: :destroy
+    has_many :orders, through: :order_promotions
+
+    has_many :codes, class_name: "Spree::PromotionCode", inverse_of: :promotion, dependent: :destroy
+    alias_method :promotion_codes, :codes
+
+    has_many :promotion_code_batches, class_name: "Spree::PromotionCodeBatch", dependent: :destroy
+
+    accepts_nested_attributes_for :promotion_actions, :promotion_rules
+
+    validates_associated :rules
+
+    validates :name, presence: true
+    validates :path, uniqueness: { allow_blank: true, case_sensitive: true }
+    validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
+    validates :per_code_usage_limit, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
+    validates :description, length: { maximum: 255 }
+    validate :apply_automatically_disallowed_with_paths
+
+    before_save :normalize_blank_values
+
+    scope :coupons, -> { joins(:codes).distinct }
+    scope :advertised, -> { where(advertise: true) }
+    scope :active, -> { has_actions.started_and_unexpired }
+    scope :started_and_unexpired, -> do
+      table = arel_table
+      time = Time.current
+
+      where(table[:starts_at].eq(nil).or(table[:starts_at].lt(time))).
+        where(table[:expires_at].eq(nil).or(table[:expires_at].gt(time)))
+    end
+    scope :has_actions, -> do
+      joins(:promotion_actions).distinct
+    end
+    scope :applied, -> { joins(:order_promotions).distinct }
+
+    self.allowed_ransackable_associations = ['codes']
+    self.allowed_ransackable_attributes = %w[name path promotion_category_id]
+    self.allowed_ransackable_scopes = %i[active]
+
+    def self.order_activatable?(order)
+      order && !UNACTIVATABLE_ORDER_STATES.include?(order.state)
+    end
+
+    def self.with_coupon_code(val)
+      joins(:codes).where(
+        PromotionCode.arel_table[:value].eq(val.downcase)
+      ).first
+    end
+
+    # All orders that have been discounted using this promotion
+    def discounted_orders
+      Spree::Order.
+        joins(:all_adjustments).
+        where(
+          spree_adjustments: {
+            source_type: "Spree::PromotionAction",
+            source_id: actions.map(&:id),
+            eligible: true
+          }
+        ).distinct
+    end
+
+    def as_json(options = {})
+      options[:except] ||= :code
+      super
+    end
+
+    def not_started?
+      !started?
+    end
+
+    def started?
+      starts_at.nil? || starts_at < Time.current
+    end
+
+    def expired?
+      expires_at.present? && expires_at < Time.current
+    end
+
+    def not_expired?
+      !expired?
+    end
+
+    def active?
+      started? && not_expired? && actions.present?
+    end
+
+    def inactive?
+      !active?
+    end
+
+    def activate(order:, line_item: nil, user: nil, path: nil, promotion_code: nil)
+      return unless self.class.order_activatable?(order)
+
+      payload = {
+        order:,
+        promotion: self,
+        line_item:,
+        user:,
+        path:,
+        promotion_code:
+      }
+
+      # Track results from actions to see if any action has been taken.
+      # Actions should return nil/false if no action has been taken.
+      # If an action returns true, then an action has been taken.
+      results = actions.map do |action|
+        action.perform(payload)
+      end
+      # If an action has been taken, report back to whatever activated this promotion.
+      action_taken = results.include?(true)
+
+      if action_taken
+        # connect to the order
+        order.order_promotions.find_or_create_by!(
+          promotion: self,
+          promotion_code:,
+        )
+        order.promotions.reset
+        order_promotions.reset
+        orders.reset
+      end
+
+      action_taken
+    end
+
+    # called anytime order.recalculate happens
+    def eligible?(promotable, promotion_code: nil)
+      return false if inactive?
+      return false if blacklisted?(promotable)
+
+      excluded_orders = eligibility_excluded_orders(promotable)
+      return false if usage_limit_exceeded?(excluded_orders:)
+      return false if promotion_code&.usage_limit_exceeded?(excluded_orders:)
+
+      !!eligible_rules(promotable, {})
+    end
+
+    # eligible_rules returns an array of promotion rules where eligible? is true for the promotable
+    # if there are no such rules, an empty array is returned
+    # if the rules make this promotable ineligible, then nil is returned (i.e. this promotable is not eligible)
+    def eligible_rules(promotable, options = {})
+      # Promotions without rules are eligible by default.
+      return [] if rules.none?
+
+      eligible = lambda { |rule| rule.eligible?(promotable, options) }
+      specific_rules = rules.select { |rule| rule.applicable?(promotable) }
+      return [] if specific_rules.none?
+
+      # If there are rules for this promotion, but no rules for this
+      # particular promotable, then the promotion is ineligible by default.
+      unless specific_rules.all?(&eligible)
+        @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
+        return nil
+      end
+      specific_rules
+    end
+
+    def products
+      rules.where(type: "Spree::Promotion::Rules::Product").flat_map(&:products).uniq
+    end
+
+    # Whether the promotion has exceeded its usage restrictions.
+    #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage limit
+    # @return true or false
+    def usage_limit_exceeded?(excluded_orders: [])
+      if usage_limit
+        usage_count(excluded_orders:) >= usage_limit
+      end
+    end
+
+    # Number of times the code has been used overall
+    #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
+    # @return [Integer] usage count
+    def usage_count(excluded_orders: [])
+      discounted_orders.
+        complete.
+        where.not(id: [excluded_orders.map(&:id)]).
+        where.not(spree_orders: { state: :canceled }).
+        count
+    end
+
+    def line_item_actionable?(order, line_item, promotion_code: nil)
+      return false if blacklisted?(line_item)
+
+      if eligible?(order, promotion_code:)
+        rules = eligible_rules(order)
+        if rules.blank?
+          true
+        else
+          rules.all? { |rule| rule.actionable? line_item }
+        end
+      else
+        false
+      end
+    end
+
+    def used_by?(user, excluded_orders = [])
+      discounted_orders.
+        complete.
+        where.not(id: excluded_orders.map(&:id)).
+        where(user:).
+        where.not(spree_orders: { state: :canceled }).
+        exists?
+    end
+
+    # Removes a promotion and any adjustments or other side effects from an
+    # order.
+    # @param order [Spree::Order] the order to remove the promotion from.
+    # @return [void]
+    def remove_from(order)
+      actions.each do |action|
+        action.remove_from(order)
+      end
+      # NOTE: this destroys the join table entry, not the promotion itself
+      order.promotions.destroy(self)
+      order.order_promotions.reset
+      order_promotions.reset
+    end
+
+    private
+
+    def blacklisted?(promotable)
+      case promotable
+      when Spree::LineItem
+        !promotable.variant.product.promotionable?
+      when Spree::Order
+        promotable.line_items.any? { |line_item| !line_item.variant.product.promotionable? }
+      end
+    end
+
+    def normalize_blank_values
+      self[:path] = nil if self[:path].blank?
+    end
+
+    def apply_automatically_disallowed_with_paths
+      return unless apply_automatically
+
+      errors.add(:apply_automatically, :disallowed_with_path) if path.present?
+    end
+
+    def eligibility_excluded_orders(promotable)
+      if promotable.is_a?(Spree::Order)
+        [promotable]
+      elsif promotable.respond_to?(:order)
+        [promotable.order]
+      else
+        []
+      end
+    end
+  end
+end

data/app/models/spree/promotion_action.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spree/preferences/persistable'
+
+module Spree
+  # Base class for all types of promotion action.
+  #
+  # PromotionActions perform the necessary tasks when a promotion is activated
+  # by an event and determined to be eligible.
+  class PromotionAction < Spree::Base
+    include Spree::Preferences::Persistable
+    include Spree::SoftDeletable
+
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions, optional: true
+
+    scope :of_type, ->(type) { where(type: Array.wrap(type).map(&:to_s)) }
+    scope :shipping, -> { of_type(Spree::Config.promotions.shipping_actions.to_a) }
+
+    def preload_relations
+      []
+    end
+
+    # Updates the state of the order or performs some other action depending on
+    # the subclass options will contain the payload from the event that
+    # activated the promotion. This will include the key :user which allows
+    # user based actions to be performed in addition to actions on the order
+    #
+    # @note This method should be overriden in subclassses.
+    def perform(_options = {})
+      raise 'perform should be implemented in a sub-class of PromotionAction'
+    end
+
+    # Removes the action from an order
+    #
+    # @note This method should be overriden in subclassses.
+    #
+    # @param order [Spree::Order] the order to remove the action from
+    # @return [void]
+    def remove_from(_order)
+      raise 'remove_from should be implemented in a sub-class of PromotionAction'
+    end
+
+    def to_partial_path
+      "spree/admin/promotions/actions/#{model_name.element}"
+    end
+
+    def available_calculators
+      Spree::Config.promotions.calculators[self.class]
+    end
+  end
+end

data/app/models/spree/promotion_advertiser.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionAdvertiser
+    def self.for_product(product)
+      promotion_ids = product.promotion_rules.map(&:promotion_id).uniq
+      Spree::Promotion.advertised.where(id: promotion_ids).reject(&:inactive?)
+    end
+  end
+end

data/app/models/spree/promotion_category.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionCategory < Spree::Base
+    validates_presence_of :name
+    has_many :promotions
+  end
+end

data/app/models/spree/promotion_chooser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionChooser
+    def initialize(adjustments)
+      @adjustments = adjustments
+    end
+
+    # Picks the best promotion from this set of adjustments, all others are
+    # marked as ineligible.
+    #
+    # @return [BigDecimal] The amount of the best adjustment
+    def update
+      if best_promotion_adjustment
+        @adjustments.select(&:eligible?).each do |adjustment|
+          next if adjustment == best_promotion_adjustment
+          adjustment.update_columns(eligible: false, updated_at: Time.current)
+        end
+        best_promotion_adjustment.amount
+      else
+        BigDecimal('0')
+      end
+    end
+
+    private
+
+    # @return The best promotion from this set of adjustments.
+    def best_promotion_adjustment
+      @best_promotion_adjustment ||= @adjustments.select(&:eligible?).min_by do |adjustment|
+        [adjustment.amount, -adjustment.id]
+      end
+    end
+  end
+end

data/app/models/spree/promotion_code/batch_builder.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+class ::Spree::PromotionCode::BatchBuilder
+  attr_reader :promotion_code_batch, :options
+
+  delegate :promotion, :number_of_codes, :base_code, to: :promotion_code_batch
+
+  DEFAULT_OPTIONS = {
+    random_code_length: 6,
+    batch_size: 1000,
+    sample_characters: ('a'..'z').to_a + (2..9).to_a.map(&:to_s)
+  }
+
+  def initialize(promotion_code_batch, options = {})
+    @promotion_code_batch = promotion_code_batch
+    options.assert_valid_keys(*DEFAULT_OPTIONS.keys)
+    @options = DEFAULT_OPTIONS.merge(options)
+  end
+
+  def build_promotion_codes
+    generate_random_codes
+    promotion_code_batch.update!(state: "completed")
+  rescue StandardError => error
+    promotion_code_batch.update!(
+      error: error.inspect,
+      state: "failed"
+    )
+    raise error
+  end
+
+  private
+
+  def generate_random_codes
+    created_codes = promotion_code_batch.promotion_codes.count
+
+    batch_size = @options[:batch_size]
+
+    while created_codes < number_of_codes
+      max_codes_to_generate = [batch_size, number_of_codes - created_codes].min
+
+      new_codes = Array.new(max_codes_to_generate) { generate_random_code }.uniq
+      codes_for_current_batch = get_unique_codes(new_codes)
+
+      codes_for_current_batch.filter! do |value|
+        Spree::PromotionCode.create!(
+          value:,
+          promotion:,
+          promotion_code_batch:
+        )
+      rescue ActiveRecord::RecordInvalid
+        false
+      end
+      created_codes += codes_for_current_batch.size
+    end
+  end
+
+  def generate_random_code
+    suffix = Array.new(@options[:random_code_length]) do
+      @options[:sample_characters].sample
+    end.join
+
+    "#{base_code}#{@promotion_code_batch.join_characters}#{suffix}"
+  end
+
+  def get_unique_codes(code_set)
+    code_set - Spree::PromotionCode.where(value: code_set.to_a).pluck(:value)
+  end
+end

data/app/models/spree/promotion_code.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class Spree::PromotionCode < Spree::Base
+  belongs_to :promotion, inverse_of: :codes, optional: true
+  belongs_to :promotion_code_batch, class_name: "Spree::PromotionCodeBatch", optional: true
+  has_many :adjustments
+
+  before_validation :normalize_code
+
+  validates :value, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
+  validates :promotion, presence: true
+  validate :promotion_not_apply_automatically, on: :create
+
+  self.allowed_ransackable_attributes = ['value']
+
+  # Whether the promotion code has exceeded its usage restrictions
+  #
+  # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage limit
+  # @return true or false
+  def usage_limit_exceeded?(excluded_orders: [])
+    if usage_limit
+      usage_count(excluded_orders:) >= usage_limit
+    end
+  end
+
+  # Number of times the code has been used overall
+  #
+  # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
+  # @return [Integer] usage count
+  def usage_count(excluded_orders: [])
+    promotion.
+      discounted_orders.
+      complete.
+      where.not(spree_orders: { state: :canceled }).
+      joins(:order_promotions).
+      where(spree_orders_promotions: { promotion_code_id: id }).
+      where.not(id: excluded_orders.map(&:id)).
+      count
+  end
+
+  def usage_limit
+    promotion.per_code_usage_limit
+  end
+
+  def promotion_not_apply_automatically
+    errors.add(:base, :disallowed_with_apply_automatically) if promotion.apply_automatically
+  end
+
+  private
+
+  def normalize_code
+    self.value = value.downcase.strip
+  end
+end

data/app/models/spree/promotion_code_batch.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionCodeBatch < Spree::Base
+    class CantProcessStartedBatch < StandardError
+    end
+
+    belongs_to :promotion, class_name: "Spree::Promotion", optional: true
+    has_many :promotion_codes, class_name: "Spree::PromotionCode", dependent: :destroy
+
+    validates :number_of_codes, numericality: { greater_than: 0 }
+    validates_presence_of :base_code, :number_of_codes
+
+    def finished?
+      state == "completed"
+    end
+  end
+end

data/app/models/spree/promotion_finder.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionFinder
+    def self.by_code_or_id(coupon_code)
+      Spree::Promotion.with_coupon_code(coupon_code.to_s) || Spree::Promotion.find(coupon_code)
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Spree
+  module PromotionHandler
+    # Decides which promotion should be activated given the current order context
+    #
+    # By activated it doesn't necessarily mean that the order will have a
+    # discount for every activated promotion. It means that the discount will be
+    # created and might eventually become eligible. The intention here is to
+    # reduce overhead. e.g. a promotion that requires item A to be eligible
+    # shouldn't be eligible unless item A is added to the order.
+    #
+    # It can be used as a wrapper for custom handlers as well. Different
+    # applications might have completely different requirements to make
+    # the promotions system accurate and performant. Here they can plug custom
+    # handler to activate promos as they wish once an item is added to cart
+    class Cart
+      attr_reader :line_item, :order
+      attr_accessor :error, :success
+
+      def initialize(order, line_item = nil)
+        @order, @line_item = order, line_item
+      end
+
+      def activate
+        promotions.each do |promotion|
+          if (line_item && promotion.eligible?(line_item, promotion_code: promotion_code(promotion))) || promotion.eligible?(order, promotion_code: promotion_code(promotion))
+            promotion.activate(line_item:, order:, promotion_code: promotion_code(promotion))
+          end
+        end
+      end
+
+      private
+
+      def promotions
+        promos = connected_order_promotions | sale_promotions
+        promos.flat_map(&:promotion_actions).group_by(&:preload_relations).each do |preload_relations, actions|
+          preload(records: actions, associations: preload_relations)
+        end
+        promos.flat_map(&:promotion_rules).group_by(&:preload_relations).each do |preload_relations, rules|
+          preload(records: rules, associations: preload_relations)
+        end
+        promos
+      end
+
+      def preload(records:, associations:)
+        if Rails::VERSION::MAJOR >= 7
+          ActiveRecord::Associations::Preloader.new(records:, associations:).call
+        else
+          ActiveRecord::Associations::Preloader.new.preload(records, associations)
+        end
+      end
+
+      def connected_order_promotions
+        order.promotions.active.includes(promotion_includes)
+      end
+
+      def sale_promotions
+        Spree::Promotion.where(apply_automatically: true).active.includes(promotion_includes)
+      end
+
+      def promotion_code(promotion)
+        order_promotion = order.order_promotions.detect { |op| op.promotion_id == promotion.id }
+        order_promotion.present? ? order_promotion.promotion_code : nil
+      end
+
+      def promotion_includes
+        [
+          :promotion_rules,
+          :promotion_actions,
+        ]
+      end
+    end
+  end
+end