solidus_core 3.0.0 → 4.5.1

data/app/jobs/spree/promotion_code_batch_job.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class PromotionCodeBatchJob < ActiveJob::Base
-    queue_as :default
-
-    def perform(promotion_code_batch)
-      PromotionCode::BatchBuilder.new(
-        promotion_code_batch
-      ).build_promotion_codes
-
-      if promotion_code_batch.email?
-        Spree::Config.promotion_code_batch_mailer_class
-          .promotion_code_batch_finished(promotion_code_batch)
-          .deliver_now
-      end
-    rescue StandardError => error
-      if promotion_code_batch.email?
-        Spree::Config.promotion_code_batch_mailer_class
-          .promotion_code_batch_errored(promotion_code_batch)
-          .deliver_now
-      end
-      raise error
-    end
-  end
-end

data/app/mailers/spree/promotion_code_batch_mailer.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class PromotionCodeBatchMailer < Spree::BaseMailer
-    def promotion_code_batch_finished(promotion_code_batch)
-      @promotion_code_batch = promotion_code_batch
-      mail(to: promotion_code_batch.email)
-    end
-
-    def promotion_code_batch_errored(promotion_code_batch)
-      @promotion_code_batch = promotion_code_batch
-      mail(to: promotion_code_batch.email)
-    end
-  end
-end

data/app/models/spree/calculator/distributed_amount.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency 'spree/calculator'
-
-# This is a calculator for line item adjustment actions. It accepts a line item
-# and calculates its weighted adjustment amount based on the value of the
-# preferred amount and the price of the other line items. More expensive line
-# items will receive a greater share of the preferred amount.
-
-module Spree
-  class Calculator::DistributedAmount < Calculator
-    preference :amount, :decimal, default: 0
-    preference :currency, :string, default: -> { Spree::Config[:currency] }
-
-    def compute_line_item(line_item)
-      return 0 unless line_item
-      return 0 unless preferred_currency.casecmp(line_item.currency).zero?
-      return 0 unless calculable.promotion.line_item_actionable?(line_item.order, line_item)
-      Spree::DistributedAmountsHandler.new(
-        actionable_line_items(line_item.order),
-        preferred_amount
-      ).amount(line_item)
-    end
-
-    private
-
-    def actionable_line_items(order)
-      order.line_items.select do |line_item|
-        calculable.promotion.line_item_actionable?(order, line_item)
-      end
-    end
-  end
-end

data/app/models/spree/calculator/flat_percent_item_total.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency 'spree/calculator'
-
-module Spree
-  class Calculator::FlatPercentItemTotal < Calculator
-    preference :flat_percent, :decimal, default: 0
-
-    def compute(object)
-      order = object.is_a?(Order) ? object : object.order
-      preferred_currency = order.currency
-      currency_exponent = ::Money::Currency.find(preferred_currency).exponent
-      computed_amount = (object.amount * preferred_flat_percent / 100).round(currency_exponent)
-
-      # We don't want to cause the promotion adjustments to push the order into a negative total.
-      if computed_amount > object.amount
-        object.amount
-      else
-        computed_amount
-      end
-    end
-  end
-end

data/app/models/spree/calculator/flexi_rate.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency 'spree/calculator'
-
-module Spree
-  class Calculator::FlexiRate < Calculator
-    preference :first_item,      :decimal, default: 0
-    preference :additional_item, :decimal, default: 0
-    preference :max_items,       :integer, default: 0
-    preference :currency,        :string,  default: ->{ Spree::Config[:currency] }
-
-    def compute(object)
-      items_count = object.quantity
-      items_count = [items_count, preferred_max_items].min unless preferred_max_items.zero?
-
-      return BigDecimal(0) if items_count == 0
-
-      additional_items_count = items_count - 1
-      preferred_first_item + preferred_additional_item * additional_items_count
-    end
-  end
-end

data/app/models/spree/calculator/percent_on_line_item.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency 'spree/calculator'
-
-module Spree
-  class Calculator::PercentOnLineItem < Calculator
-    preference :percent, :decimal, default: 0
-
-    def compute(object)
-      (object.amount * preferred_percent) / 100
-    end
-  end
-end

data/app/models/spree/calculator/tiered_flat_rate.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency 'spree/calculator'
-
-module Spree
-  class Calculator::TieredFlatRate < Calculator
-    preference :base_amount, :decimal, default: 0
-    preference :tiers, :hash, default: {}
-    preference :currency, :string, default: -> { Spree::Config[:currency] }
-
-    before_validation do
-      # Convert tier values to decimals. Strings don't do us much good.
-      if preferred_tiers.is_a?(Hash)
-        self.preferred_tiers = preferred_tiers.map do |key, value|
-          [cast_to_d(key.to_s), cast_to_d(value.to_s)]
-        end.to_h
-      end
-    end
-
-    validate :preferred_tiers_content
-
-    def compute(object)
-      _base, amount = preferred_tiers.sort.reverse.detect do |value, _|
-        object.amount >= value
-      end
-
-      if preferred_currency.casecmp(object.currency).zero?
-        amount || preferred_base_amount
-      else
-        0
-      end
-    end
-
-    private
-
-    def cast_to_d(value)
-      value.to_s.to_d
-    rescue ArgumentError
-      BigDecimal(0)
-    end
-
-    def preferred_tiers_content
-      if preferred_tiers.is_a? Hash
-        unless preferred_tiers.keys.all?{ |key| key.is_a?(Numeric) && key > 0 }
-          errors.add(:base, :keys_should_be_positive_number)
-        end
-      else
-        errors.add(:preferred_tiers, :should_be_hash)
-      end
-    end
-  end
-end

data/app/models/spree/calculator/tiered_percent.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require_dependency 'spree/calculator'
-
-module Spree
-  class Calculator::TieredPercent < Calculator
-    preference :base_percent, :decimal, default: 0
-    preference :tiers, :hash, default: {}
-    preference :currency, :string, default: -> { Spree::Config[:currency] }
-
-    before_validation do
-      # Convert tier values to decimals. Strings don't do us much good.
-      if preferred_tiers.is_a?(Hash)
-        self.preferred_tiers = preferred_tiers.map do |key, value|
-          [cast_to_d(key.to_s), cast_to_d(value.to_s)]
-        end.to_h
-      end
-    end
-
-    validates :preferred_base_percent, numericality: {
-      greater_than_or_equal_to: 0,
-      less_than_or_equal_to: 100
-    }
-    validate :preferred_tiers_content
-
-    def compute(object)
-      order = object.is_a?(Order) ? object : object.order
-
-      _base, percent = preferred_tiers.sort.reverse.detect do |value, _|
-        order.item_total >= value
-      end
-
-      if preferred_currency.casecmp(order.currency).zero?
-        currency_exponent = ::Money::Currency.find(preferred_currency).exponent
-        (object.amount * (percent || preferred_base_percent) / 100).round(currency_exponent)
-      else
-        0
-      end
-    end
-
-    private
-
-    def cast_to_d(value)
-      value.to_s.to_d
-    rescue ArgumentError
-      BigDecimal(0)
-    end
-
-    def preferred_tiers_content
-      if preferred_tiers.is_a? Hash
-        unless preferred_tiers.keys.all?{ |key| key.is_a?(Numeric) && key > 0 }
-          errors.add(:base, :keys_should_be_positive_number)
-        end
-        unless preferred_tiers.values.all?{ |key| key.is_a?(Numeric) && key >= 0 && key <= 100 }
-          errors.add(:base, :values_should_be_percent)
-        end
-      else
-        errors.add(:preferred_tiers, :should_be_hash)
-      end
-    end
-  end
-end

data/app/models/spree/line_item_action.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class LineItemAction < Spree::Base
-    belongs_to :line_item, optional: true
-    belongs_to :action, class_name: "Spree::PromotionAction", optional: true
-  end
-end

data/app/models/spree/order_promotion.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  # Spree::OrderPromotion represents the relationship between:
-  #
-  # 1. A promotion that a user attempted to apply to their order
-  # 2. The specific code that they used
-  class OrderPromotion < Spree::Base
-    self.table_name = 'spree_orders_promotions'
-
-    belongs_to :order, class_name: 'Spree::Order', optional: true
-    belongs_to :promotion, class_name: 'Spree::Promotion', optional: true
-    belongs_to :promotion_code, class_name: 'Spree::PromotionCode', optional: true
-
-    validates :order, presence: true
-    validates :promotion, presence: true
-    validates :promotion_code, presence: true, if: :require_promotion_code?
-
-    self.whitelisted_ransackable_associations = %w[promotion_code]
-
-    private
-
-    def require_promotion_code?
-      promotion && !promotion.apply_automatically && promotion.codes.any?
-    end
-  end
-end

data/app/models/spree/promotion/actions/create_adjustment.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Actions
-      class CreateAdjustment < PromotionAction
-        include Spree::CalculatedAdjustments
-        include Spree::AdjustmentSource
-
-        has_many :adjustments, as: :source
-
-        delegate :eligible?, to: :promotion
-
-        before_validation :ensure_action_has_calculator
-        before_destroy :remove_adjustments_from_incomplete_orders
-        before_discard :remove_adjustments_from_incomplete_orders
-
-        # Creates the adjustment related to a promotion for the order passed
-        # through options hash
-        #
-        # Returns `true` if an adjustment is applied to an order,
-        # `false` if the promotion has already been applied.
-        def perform(options = {})
-          order = options[:order]
-          return if promotion_credit_exists?(order)
-
-          amount = compute_amount(order)
-          order.adjustments.create!(
-            amount: amount,
-            order: order,
-            source: self,
-            promotion_code: options[:promotion_code],
-            label: I18n.t('spree.adjustment_labels.order', promotion: Spree::Promotion.model_name.human, promotion_name: promotion.name)
-          )
-          true
-        end
-
-        # Ensure a negative amount which does not exceed the sum of the order's
-        # item_total and ship_total
-        def compute_amount(calculable)
-          amount = calculator.compute(calculable)
-          amount ||= BigDecimal(0)
-          amount = amount.abs
-          [(calculable.item_total + calculable.ship_total), amount].min * -1
-        end
-
-        # Removes any adjustments generated by this action from the order.
-        # @param order [Spree::Order] the order to remove the action from.
-        # @return [void]
-        def remove_from(order)
-          order.adjustments.each do |adjustment|
-            if adjustment.source == self
-              order.adjustments.destroy(adjustment)
-            end
-          end
-        end
-
-        private
-
-        # Tells us if there if the specified promotion is already associated with the line item
-        # regardless of whether or not its currently eligible. Useful because generally
-        # you would only want a promotion action to apply to order no more than once.
-        #
-        # Receives an adjustment +source+ (here a PromotionAction object) and tells
-        # if the order has adjustments from that already
-        def promotion_credit_exists?(adjustable)
-          adjustments.where(adjustable_id: adjustable.id).exists?
-        end
-
-        def ensure_action_has_calculator
-          return if calculator
-          self.calculator = Calculator::FlatPercentItemTotal.new
-        end
-      end
-    end
-  end
-end

data/app/models/spree/promotion/actions/create_item_adjustments.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Actions
-      class CreateItemAdjustments < PromotionAction
-        include Spree::CalculatedAdjustments
-        include Spree::AdjustmentSource
-
-        has_many :adjustments, as: :source
-
-        delegate :eligible?, to: :promotion
-
-        before_validation :ensure_action_has_calculator
-        before_destroy :remove_adjustments_from_incomplete_orders
-        before_discard :remove_adjustments_from_incomplete_orders
-
-        def perform(payload = {})
-          order = payload[:order]
-          promotion = payload[:promotion]
-          promotion_code = payload[:promotion_code]
-
-          results = line_items_to_adjust(promotion, order).map do |line_item|
-            create_adjustment(line_item, order, promotion_code)
-          end
-
-          results.any?
-        end
-
-        # Ensure a negative amount which does not exceed the sum of the order's
-        # item_total and ship_total
-        def compute_amount(adjustable)
-          order = adjustable.is_a?(Order) ? adjustable : adjustable.order
-          return 0 unless promotion.line_item_actionable?(order, adjustable)
-          promotion_amount = calculator.compute(adjustable)
-          promotion_amount ||= BigDecimal(0)
-          promotion_amount = promotion_amount.abs
-          [adjustable.amount, promotion_amount].min * -1
-        end
-
-        # Removes any adjustments generated by this action from the order's
-        #  line items.
-        # @param order [Spree::Order] the order to remove the action from.
-        # @return [void]
-        def remove_from(order)
-          order.line_items.each do |line_item|
-            line_item.adjustments.each do |adjustment|
-              if adjustment.source == self
-                line_item.adjustments.destroy(adjustment)
-              end
-            end
-          end
-        end
-
-        private
-
-        def create_adjustment(adjustable, order, promotion_code)
-          amount = compute_amount(adjustable)
-          return if amount == 0
-          adjustable.adjustments.create!(
-            source: self,
-            amount: amount,
-            order: order,
-            promotion_code: promotion_code,
-            label: I18n.t('spree.adjustment_labels.line_item', promotion: Spree::Promotion.model_name.human, promotion_name: promotion.name)
-          )
-          true
-        end
-
-        # Tells us if there if the specified promotion is already associated with the line item
-        # regardless of whether or not its currently eligible. Useful because generally
-        # you would only want a promotion action to apply to line item no more than once.
-        #
-        # Receives an adjustment +source+ (here a PromotionAction object) and tells
-        # if the order has adjustments from that already
-        def promotion_credit_exists?(adjustable)
-          adjustments.where(adjustable_id: adjustable.id).exists?
-        end
-
-        def ensure_action_has_calculator
-          return if calculator
-          self.calculator = Calculator::PercentOnLineItem.new
-        end
-
-        def line_items_to_adjust(promotion, order)
-          excluded_ids = adjustments.
-            where(adjustable_id: order.line_items.pluck(:id), adjustable_type: 'Spree::LineItem').
-            pluck(:adjustable_id).
-            to_set
-
-          order.line_items.select do |line_item|
-            !excluded_ids.include?(line_item.id) &&
-              promotion.line_item_actionable?(order, line_item)
-          end
-        end
-      end
-    end
-  end
-end

data/app/models/spree/promotion/actions/create_quantity_adjustments.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Actions
-      class CreateQuantityAdjustments < CreateItemAdjustments
-        preference :group_size, :integer, default: 1
-
-        has_many :line_item_actions, foreign_key: :action_id, dependent: :destroy
-        has_many :line_items, through: :line_item_actions
-
-        ##
-        # Computes the amount for the adjustment based on the line item and any
-        # other applicable items in the order. The rules for this specific
-        # adjustment are as follows:
-        #
-        # = Setup
-        #
-        # We have a quantity group promotion on t-shirts. If a user orders 3
-        # t-shirts, they get $5 off of each. The shirts come in one size and three
-        # colours: red, blue, and white.
-        #
-        # == Scenario 1
-        #
-        # User has 2 red shirts, 1 white shirt, and 1 blue shirt in their
-        # order. We want to compute the adjustment amount for the white shirt.
-        #
-        # *Result:* -$5
-        #
-        # *Reasoning:* There are a total of 4 items that are eligible for the
-        # promotion. Since that is greater than 3, we can discount the items. The
-        # white shirt has a quantity of 1, therefore it will get discounted by
-        # +adjustment_amount * 1+ or $5.
-        #
-        # === Scenario 1-1
-        #
-        # What about the blue shirt? How much does it get discounted?
-        #
-        # *Result:* $0
-        #
-        # *Reasoning:* We have a total quantity of 4. However, we only apply the
-        # adjustment to groups of 3. Assuming the white and red shirts have already
-        # had their adjustment calculated, that means 3 units have been discounted.
-        # Leaving us with a lonely blue shirt that isn't part of a group of 3.
-        # Therefore, it does not receive the discount.
-        #
-        # == Scenario 2
-        #
-        # User has 4 red shirts in their order. What is the amount?
-        #
-        # *Result:* -$15
-        #
-        # *Reasoning:* The total quantity of eligible items is 4, so we the
-        # adjustment will be non-zero. However, we only apply it to groups of 3,
-        # therefore there is one extra item that is not eligible for the
-        # adjustment. +adjustment_amount * 3+ or $15.
-        #
-        def compute_amount(line_item)
-          adjustment_amount = calculator.compute(PartialLineItem.new(line_item))
-          adjustment_amount ||= BigDecimal(0)
-          adjustment_amount = adjustment_amount.abs
-
-          order = line_item.order
-          line_items = actionable_line_items(order)
-
-          actioned_line_items = order.line_item_adjustments.reload.
-            select { |adjustment| adjustment.source == self && adjustment.amount < 0 }.
-            map(&:adjustable)
-          other_line_items = actioned_line_items - [line_item]
-
-          applicable_quantity = total_applicable_quantity(line_items)
-          used_quantity = total_used_quantity(other_line_items)
-          usable_quantity = [
-            applicable_quantity - used_quantity,
-            line_item.quantity
-          ].min
-
-          persist_quantity(usable_quantity, line_item)
-
-          amount = adjustment_amount * usable_quantity
-          [line_item.amount, amount].min * -1
-        end
-
-        private
-
-        def actionable_line_items(order)
-          order.line_items.select do |item|
-            promotion.line_item_actionable? order, item
-          end
-        end
-
-        def total_applicable_quantity(line_items)
-          total_quantity = line_items.sum(&:quantity)
-          extra_quantity = total_quantity % preferred_group_size
-
-          total_quantity - extra_quantity
-        end
-
-        def total_used_quantity(line_items)
-          line_item_actions.where(
-            line_item_id: line_items.map(&:id)
-          ).sum(:quantity)
-        end
-
-        def persist_quantity(quantity, line_item)
-          line_item_action = line_item_actions.where(
-            line_item_id: line_item.id
-          ).first_or_initialize
-          line_item_action.quantity = quantity
-          line_item_action.save!
-        end
-
-        ##
-        # Used specifically for PercentOnLineItem calculator. That calculator uses
-        # `line_item.amount`, however we might not necessarily want to discount the
-        # entire amount. This class allows us to determine the discount per
-        # quantity and then calculate the adjustment amount the way we normally do
-        # for flat rate adjustments.
-        class PartialLineItem
-          def initialize(line_item)
-            @line_item = line_item
-          end
-
-          def amount
-            @line_item.price
-          end
-
-          def order
-            @line_item.order
-          end
-
-          def currency
-            @line_item.currency
-          end
-        end
-      end
-    end
-  end
-end

data/app/models/spree/promotion/actions/free_shipping.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Actions
-      class FreeShipping < Spree::PromotionAction
-        def perform(payload = {})
-          order = payload[:order]
-          promotion_code = payload[:promotion_code]
-
-          created_adjustments = order.shipments.map do |shipment|
-            next if promotion_credit_exists?(shipment)
-
-            shipment.adjustments.create!(
-              order: shipment.order,
-              amount: compute_amount(shipment),
-              source: self,
-              promotion_code: promotion_code,
-              label: label
-            )
-          end
-
-          # Did we actually end up creating any adjustments?
-          # If so, then this action should be classed as 'successful'
-          created_adjustments.any?
-        end
-
-        def label
-          "#{I18n.t('spree.promotion')} (#{promotion.name})"
-        end
-
-        def compute_amount(shipment)
-          shipment.cost * -1
-        end
-
-        # Removes any adjustments generated by this action from the order's
-        #  shipments.
-        # @param order [Spree::Order] the order to remove the action from.
-        # @return [void]
-        def remove_from(order)
-          order.shipments.each do |shipment|
-            shipment.adjustments.each do |adjustment|
-              if adjustment.source == self
-                shipment.adjustments.destroy(adjustment)
-              end
-            end
-          end
-        end
-
-        private
-
-        def promotion_credit_exists?(shipment)
-          shipment.adjustments.where(source: self).exists?
-        end
-      end
-    end
-  end
-end