solidus_legacy_promotions 4.4.0

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

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

@@ -0,0 +1,62 @@
+# 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_contents.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Spree
+  class OrderContents < Spree::SimpleOrderContents
+    # Updates the order's line items with the params passed in.
+    # Also runs the PromotionHandler::Cart.
+    def update_cart(params)
+      if order.update(params)
+        unless order.completed?
+          order.line_items = order.line_items.select { |li| li.quantity > 0 }
+          # Update totals, then check if the order is eligible for any cart promotions.
+          # If we do not update first, then the item total will be wrong and ItemTotal
+          # promotion rules would not be triggered.
+          reload_totals
+          order.check_shipments_and_restart_checkout
+          ::Spree::PromotionHandler::Cart.new(order).activate
+        end
+        reload_totals
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    def after_add_or_remove(line_item, options = {})
+      reload_totals
+      shipment = options[:shipment]
+      shipment.present? ? shipment.update_amounts : order.check_shipments_and_restart_checkout
+      ::Spree::PromotionHandler::Cart.new(order, line_item).activate
+      reload_totals
+      line_item
+    end
+  end
+end

data/app/models/spree/order_promotion.rb

@@ -0,0 +1,27 @@
+# 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/permission_sets/promotion_display.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Spree
+  module PermissionSets
+    # Read-only permissions for promotions.
+    #
+    # This permission set allows users to view all related information about
+    # promotions, also from the admin panel, including:
+    #
+    # - Promotions
+    # - Promotion rules
+    # - Promotion actions
+    # - Promotion categories
+    # - Promotion codes
+    class PromotionDisplay < PermissionSets::Base
+      def activate!
+        can [:read, :admin, :edit], Spree::Promotion
+        can [:read, :admin], Spree::PromotionRule
+        can [:read, :admin], Spree::PromotionAction
+        can [:read, :admin], Spree::PromotionCategory
+        can [:read, :admin], Spree::PromotionCode
+      end
+    end
+  end
+end

data/app/models/spree/permission_sets/promotion_management.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Spree
+  module PermissionSets
+    # Full permissions for promotion management.
+    #
+    # This permission set grants full control over all promotion and related resources,
+    # including:
+    #
+    # - Promotions
+    # - Promotion rules
+    # - Promotion actions
+    # - Promotion categories
+    # - Promotion codes
+    class PromotionManagement < PermissionSets::Base
+      def activate!
+        can :manage, Spree::Promotion
+        can :manage, Spree::PromotionRule
+        can :manage, Spree::PromotionAction
+        can :manage, Spree::PromotionCategory
+        can :manage, Spree::PromotionCode
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,98 @@
+# 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:,
+            order:,
+            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

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

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