solidus_core 4.3.5 → 4.4.1

data/app/models/spree/promotion.rb

@@ -1,271 +0,0 @@
-# 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: order,
-        promotion: self,
-        line_item: line_item,
-        user: user,
-        path: path,
-        promotion_code: 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: 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: excluded_orders)
-      return false if promotion_code&.usage_limit_exceeded?(excluded_orders: 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: 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: 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: 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

@@ -1,47 +0,0 @@
-# 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.environment.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
-  end
-end

data/app/models/spree/promotion_category.rb

@@ -1,8 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-# 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

@@ -1,64 +0,0 @@
-# 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 = 0
-    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.each do |value|
-        Spree::PromotionCode.create!(
-          value: value,
-          promotion: promotion,
-          promotion_code_batch: promotion_code_batch
-        )
-      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

@@ -1,54 +0,0 @@
-# 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: 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: self.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

@@ -1,27 +0,0 @@
-# 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
-
-    def process
-      if state == "pending"
-        update!(state: "processing")
-        PromotionCodeBatchJob.perform_later(self)
-      else
-        raise CantProcessStartedBatch.new("Batch #{id} already started")
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-# 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: line_item, order: 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: records, associations: 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