solidus_core 4.3.4 → 4.4.0

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/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.allowed_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,81 +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
-
-        def preload_relations
-          [:calculator]
-        end
-
-        # 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,98 +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 preload_relations
-          [:calculator]
-        end
-
-        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)
-          order.line_items.select do |line_item|
-            line_item.adjustments.none? { |adjustment| adjustment.source == self } &&
-              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,59 +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]
-          return false unless promotion.eligible? order
-
-          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

data/app/models/spree/promotion/order_adjustments_recalculator.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-
-    # This class encapsulates all the things the promotion system does to
-    # an order. It is called from the `Spree::OrderUpdater` before taxes are
-    # calculated, such that taxes always respect promotions.
-
-    # This class iterates over all existing promotion adjustments and recalculates
-    # their amount and eligibility using their adjustment source.
-    class OrderAdjustmentsRecalculator
-      def initialize(order)
-        @order = order
-      end
-
-      def call
-        all_items = line_items + shipments
-        all_items.each do |item|
-          promotion_adjustments = item.adjustments.select(&:promotion?)
-
-          promotion_adjustments.each { |adjustment| recalculate(adjustment) }
-          Spree::Config.promotion_chooser_class.new(promotion_adjustments).update
-
-          item.promo_total = promotion_adjustments.select(&:eligible?).sum(&:amount)
-        end
-        # Update and select the best promotion adjustment for the order.
-        # We don't update the order.promo_total yet. Order totals are updated later
-        # in #update_adjustment_total since they include the totals from the order's
-        # line items and/or shipments.
-        order_promotion_adjustments = order.adjustments.select(&:promotion?)
-        order_promotion_adjustments.each { |adjustment| recalculate(adjustment) }
-        Spree::Config.promotion_chooser_class.new(order_promotion_adjustments).update
-
-        order.promo_total = all_items.sum(&:promo_total) +
-                            order_promotion_adjustments.
-                              select(&:eligible?).
-                              select(&:promotion?).
-                              sum(&:amount)
-        order
-      end
-
-      private
-
-      attr_reader :order
-      delegate :line_items, :shipments, to: :order
-
-      # Recalculate and persist the amount from this adjustment's source based on
-      # the adjustable ({Order}, {Shipment}, or {LineItem})
-      #
-      # If the adjustment has no source (such as when created manually from the
-      # admin) or is closed, this is a noop.
-      #
-      # @return [BigDecimal] New amount of this adjustment
-      def recalculate(adjustment)
-        if adjustment.finalized?
-          return adjustment.amount
-        end
-
-        # If the adjustment has no source, do not attempt to re-calculate the
-        # amount.
-        # Some scenarios where this happens:
-        #   - Adjustments that are manually created via the admin backend
-        #   - PromotionAction adjustments where the PromotionAction was deleted
-        #     after the order was completed.
-        if adjustment.source.present?
-          adjustment.amount = adjustment.source.compute_amount(adjustment.adjustable)
-
-          adjustment.eligible = calculate_eligibility(adjustment)
-
-          # Persist only if changed
-          # This is only not a save! to avoid the extra queries to load the order
-          # (for validations) and to touch the adjustment.
-          adjustment.update_columns(eligible: adjustment.eligible, amount: adjustment.amount, updated_at: Time.current) if adjustment.changed?
-        end
-        adjustment.amount
-      end
-
-      # Calculates based on attached promotion (if this is a promotion
-      # adjustment) whether this promotion is still eligible.
-      # @api private
-      # @return [true,false] Whether this adjustment is eligible
-      def calculate_eligibility(adjustment)
-        if !adjustment.finalized? && adjustment.source
-          adjustment.source.promotion.eligible?(adjustment.adjustable, promotion_code: adjustment.promotion_code)
-        else
-          adjustment.eligible?
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Rules
-      class FirstOrder < PromotionRule
-        attr_reader :user, :email
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        def eligible?(order, options = {})
-          @user = order.try(:user) || options[:user]
-          @email = order.email
-
-          if user || email
-            if !completed_orders.blank? && completed_orders.first != order
-              eligibility_errors.add(:base, eligibility_error_message(:not_first_order), error_code: :not_first_order)
-            end
-          end
-
-          eligibility_errors.empty?
-        end
-
-        private
-
-        def completed_orders
-          user ? user.orders.complete : orders_by_email
-        end
-
-        def orders_by_email
-          Spree::Order.where(email: email).complete
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Rules
-      class FirstRepeatPurchaseSince < PromotionRule
-        preference :days_ago, :integer, default: 365
-        validates :preferred_days_ago, numericality: { only_integer: true, greater_than: 0 }
-
-        # This promotion is applicable to orders only.
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        # This is never eligible if the order does not have a user, and that user does not have any previous completed orders.
-        #
-        # This is eligible if the user's most recently completed order is more than the preferred days ago
-        # @param order [Spree::Order]
-        def eligible?(order, _options = {})
-          return false unless order.user
-
-          last_order = last_completed_order(order.user)
-          return false unless last_order
-
-          last_order.completed_at < preferred_days_ago.days.ago
-        end
-
-        private
-
-        def last_completed_order(user)
-          user.orders.complete.order(:completed_at).last
-        end
-      end
-    end
-  end
-end