solidus_core 3.0.0 → 4.5.1

data/app/models/spree/promotion.rb

@@ -1,284 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    MATCH_POLICIES = %w(all any)
-    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"
-    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)
-    end
-    scope :applied, -> { joins(:order_promotions).distinct }
-
-    self.whitelisted_ransackable_associations = ['codes']
-    self.whitelisted_ransackable_attributes = %w[name path promotion_category_id]
-    def self.ransackable_scopes(*)
-      %i(active)
-    end
-
-    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
-
-    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.for(promotable)
-      return [] if specific_rules.none?
-
-      if match_all?
-        # 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
-      else
-        unless specific_rules.any?(&eligible)
-          @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
-          return nil
-        end
-        specific_rules.select(&eligible)
-      end
-    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: [])
-      Spree::Adjustment.promotion.
-        eligible.
-        in_completed_orders(excluded_orders: excluded_orders).
-        where(source_id: actions).
-        count(:order_id)
-    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.send(match_all? ? :all? : :any?) do |rule|
-            rule.actionable? line_item
-          end
-        end
-      else
-        false
-      end
-    end
-
-    def used_by?(user, excluded_orders = [])
-      [
-        :adjustments,
-        :line_item_adjustments,
-        :shipment_adjustments
-      ].any? do |adjustment_type|
-        user.orders.complete.joins(adjustment_type).where(
-          spree_adjustments: {
-            source_type: "Spree::PromotionAction",
-            source_id: actions.map(&:id),
-            eligible: true
-          }
-        ).where.not(
-          id: excluded_orders.map(&:id)
-        ).any?
-      end
-    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.product.promotionable?
-      when Spree::Order
-        promotable.line_items.joins(:product).where(spree_products: { promotionable: false }).exists?
-      end
-    end
-
-    def normalize_blank_values
-      self[:path] = nil if self[:path].blank?
-    end
-
-    def match_all?
-      match_policy == "all"
-    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,43 +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) }
-
-    # 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,50 +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
-
-  validates :value, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
-  validates :promotion, presence: true
-  validate :promotion_not_apply_automatically, on: :create
-
-  before_save :normalize_code
-
-  self.whitelisted_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: [])
-    adjustments.
-    eligible.
-    in_completed_orders(excluded_orders: excluded_orders).
-    count(:order_id)
-  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,55 +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
-        connected_order_promotions | sale_promotions
-      end
-
-      def connected_order_promotions
-        Spree::Promotion.active.includes(:promotion_rules).
-          joins(:order_promotions).
-          where(spree_orders_promotions: { order_id: order.id }).readonly(false).to_a
-      end
-
-      def sale_promotions
-        Spree::Promotion.where(apply_automatically: true).active.includes(:promotion_rules)
-      end
-
-      def promotion_code(promotion)
-        order_promotion = Spree::OrderPromotion.where(order: order, promotion: promotion).first
-        order_promotion.present? ? order_promotion.promotion_code : nil
-      end
-    end
-  end
-end

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

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  module PromotionHandler
-    class Coupon
-      attr_reader :order, :coupon_code
-      attr_accessor :error, :success, :status_code
-
-      def initialize(order)
-        @order = order
-        @coupon_code = order.coupon_code && order.coupon_code.downcase
-      end
-
-      def apply
-        if coupon_code.present?
-          if promotion.present? && promotion.active? && promotion.actions.exists?
-            handle_present_promotion(promotion)
-          elsif promotion_code&.promotion&.expired?
-            set_error_code :coupon_code_expired
-          else
-            set_error_code :coupon_code_not_found
-          end
-        end
-
-        self
-      end
-
-      def remove
-        if promotion.blank?
-          set_error_code :coupon_code_not_found
-        elsif !promotion_exists_on_order?(order, promotion)
-          set_error_code :coupon_code_not_present
-        else
-          promotion.remove_from(order)
-          order.recalculate
-          set_success_code :coupon_code_removed
-        end
-
-        self
-      end
-
-      def set_success_code(status_code)
-        @status_code = status_code
-        @success = I18n.t(status_code, scope: 'spree')
-      end
-
-      def set_error_code(status_code, options = {})
-        @status_code = status_code
-        @error = options[:error] || I18n.t(status_code, scope: 'spree')
-      end
-
-      def promotion
-        @promotion ||= begin
-          if promotion_code && promotion_code.promotion.active?
-            promotion_code.promotion
-          end
-        end
-      end
-
-      def successful?
-        success.present? && error.blank?
-      end
-
-      private
-
-      def promotion_code
-        @promotion_code ||= Spree::PromotionCode.where(value: coupon_code).first
-      end
-
-      def handle_present_promotion(promotion)
-        return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded? || promotion_code.usage_limit_exceeded?
-        return promotion_applied if promotion_exists_on_order?(order, promotion)
-
-        unless promotion.eligible?(order, promotion_code: promotion_code)
-          set_promotion_eligibility_error_code(promotion)
-          return (error || ineligible_for_this_order)
-        end
-
-        # If any of the actions for the promotion return `true`,
-        # then result here will also be `true`.
-        result = promotion.activate(order: order, promotion_code: promotion_code)
-        if result
-          order.recalculate
-          set_success_code :coupon_code_applied
-        else
-          set_error_code :coupon_code_unknown_error
-        end
-      end
-
-      def set_promotion_eligibility_error_code(promotion)
-        return unless eligibility_error_code_present?(promotion)
-
-        eligibility_error = promotion.eligibility_errors.details[:base].first
-
-        @status_code = eligibility_error[:error_code]
-        @error = eligibility_error[:error]
-      end
-
-      def promotion_usage_limit_exceeded
-        set_error_code :coupon_code_max_usage
-      end
-
-      def ineligible_for_this_order
-        set_error_code :coupon_code_not_eligible
-      end
-
-      def promotion_applied
-        set_error_code :coupon_code_already_applied
-      end
-
-      def promotion_exists_on_order?(order, promotion)
-        order.promotions.include? promotion
-      end
-
-      def eligibility_error_code_present?(promotion)
-        promotion.eligibility_errors.present? &&
-          promotion.eligibility_errors.details.present? &&
-          promotion.eligibility_errors.details.key?(:base) &&
-          promotion.eligibility_errors.details[:base].first[:error_code].present?
-      end
-    end
-  end
-end