solidus_core_devise_token_auth 2.8.0.alpha.0

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

@@ -0,0 +1,80 @@
+# 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)
+          if !amount.is_a?(BigDecimal)
+            Spree::Deprecation.warn "#{calculator.class.name}#compute returned #{amount.inspect}, it should return a BigDecimal"
+          end
+          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,102 @@
+# 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)
+          if !promotion_amount.is_a?(BigDecimal)
+            Spree::Deprecation.warn "#{calculator.class.name}#compute returned #{promotion_amount.inspect}, it should return a BigDecimal"
+          end
+          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

@@ -0,0 +1,142 @@
+# 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))
+          if !adjustment_amount.is_a?(BigDecimal)
+            Spree::Deprecation.warn "#{calculator.class.name}#compute returned #{adjustment_amount.inspect}, it should return a BigDecimal"
+          end
+          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 { |a| a.source == self && a.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,57 @@
+# 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]
+
+          results = order.shipments.map do |shipment|
+            return false if promotion_credit_exists?(shipment)
+            shipment.adjustments.create!(
+              order: shipment.order,
+              amount: compute_amount(shipment),
+              source: self,
+              promotion_code: promotion_code,
+              label: label
+            )
+            true
+          end
+          # Did we actually end up applying any adjustments?
+          # If so, then this action should be classed as 'successful'
+          results.any? { |r| r == true }
+        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/rules/first_order.rb

@@ -0,0 +1,40 @@
+# 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))
+            end
+          else
+            eligibility_errors.add(:base, eligibility_error_message(:no_user_or_email_specified))
+          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

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

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    module Rules
+      # A rule to apply to an order greater than (or greater than or equal to)
+      # a specific amount
+      class ItemTotal < PromotionRule
+        preference :amount, :decimal, default: 100.00
+        preference :currency, :string, default: ->{ Spree::Config[:currency] }
+        preference :operator, :string, default: '>'
+
+        OPERATORS = ['gt', 'gte']
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, _options = {})
+          return false unless order.currency == preferred_currency
+          item_total = order.item_total
+          unless item_total.send(preferred_operator == 'gte' ? :>= : :>, BigDecimal(preferred_amount.to_s))
+            eligibility_errors.add(:base, ineligible_message)
+          end
+
+          eligibility_errors.empty?
+        end
+
+        private
+
+        def formatted_amount
+          Spree::Money.new(preferred_amount, currency: preferred_currency).to_s
+        end
+
+        def ineligible_message
+          if preferred_operator == 'gte'
+            eligibility_error_message(:item_total_less_than, amount: formatted_amount)
+          else
+            eligibility_error_message(:item_total_less_than_or_equal, amount: formatted_amount)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion
+    module Rules
+      class NthOrder < PromotionRule
+        preference :nth_order, :integer, default: 2
+        # It does not make sense to have this apply to the first order using preferred_nth_order == 1
+        # Instead we could use the first_order rule
+        validates :preferred_nth_order, numericality: { only_integer: true, greater_than: 1 }
+
+        # 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.
+        #
+        # Use the first order rule if you want a promotion to be applied to the first order for a user.
+        # @param order [Spree::Order]
+        def eligible?(order, _options = {})
+          return false unless order.user
+
+          nth_order?(order)
+        end
+
+        private
+
+        def completed_order_count(order)
+          order.
+            user.
+            orders.
+            complete.
+            where(Spree::Order.arel_table[:completed_at].lt(order.completed_at || Time.current)).
+            count
+        end
+
+        def nth_order?(order)
+          count = completed_order_count(order) + 1
+          count == preferred_nth_order
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    module Rules
+      class OneUsePerUser < PromotionRule
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, _options = {})
+          if order.user.present?
+            if promotion.used_by?(order.user, [order])
+              eligibility_errors.add(:base, eligibility_error_message(:limit_once_per_user))
+            end
+          else
+            eligibility_errors.add(:base, eligibility_error_message(:no_user_specified))
+          end
+
+          eligibility_errors.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    module Rules
+      class OptionValue < PromotionRule
+        MATCH_POLICIES = %w(any)
+        preference :match_policy, :string, default: MATCH_POLICIES.first
+        preference :eligible_values, :hash
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(promotable, _options = {})
+          case preferred_match_policy
+          when 'any'
+            promotable.line_items.any? { |item| actionable?(item) }
+          end
+        end
+
+        def actionable?(line_item)
+          pid = line_item.product.id
+          ovids = line_item.variant.option_values.pluck(:id)
+
+          product_ids.include?(pid) && (value_ids(pid) & ovids).present?
+        end
+
+        def preferred_eligible_values
+          values = preferences[:eligible_values] || {}
+          Hash[values.keys.map(&:to_i).zip(
+            values.values.map do |v|
+              (v.is_a?(Array) ? v : v.split(",")).map(&:to_i)
+            end
+          )]
+        end
+
+        private
+
+        def product_ids
+          preferred_eligible_values.keys
+        end
+
+        def value_ids(product_id)
+          preferred_eligible_values[product_id]
+        end
+      end
+    end
+  end
+end