solidus_promotions 4.4.0

data/app/models/solidus_promotions/benefits/create_discounted_item.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Benefits
+    class CreateDiscountedItem < Benefit
+      include OrderBenefit
+      preference :variant_id, :integer
+      preference :quantity, :integer, default: 1
+      preference :necessary_quantity, :integer, default: 1
+
+      def perform(order)
+        line_item = find_item(order) || create_item(order)
+        set_quantity(line_item, determine_item_quantity(order))
+        line_item.current_discounts << discount(line_item)
+      end
+
+      def remove_from(order)
+        line_item = find_item(order)
+        order.line_items.destroy(line_item)
+      end
+
+      private
+
+      def find_item(order)
+        order.line_items.detect { |line_item| line_item.managed_by_order_benefit == self }
+      end
+
+      def create_item(order)
+        order.line_items.create!(quantity: determine_item_quantity(order), variant: variant, managed_by_order_benefit: self)
+      end
+
+      def determine_item_quantity(order)
+        # Integer division will floor automatically, which is what we want here:
+        # 1 Item, 2 needed: 1 * 1 / 2 => 0
+        # 5 items, 2 preferred, 2 needed: 5 / 2 * 2 => 4
+        applicable_line_items(order).sum(&:quantity) / preferred_necessary_quantity * preferred_quantity
+      end
+
+      def set_quantity(line_item, quantity)
+        line_item.quantity_setter = self
+        line_item.quantity = quantity
+      end
+
+      def variant
+        Spree::Variant.find(preferred_variant_id)
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/calculators/distributed_amount.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_dependency "spree/calculator"
+
+# This is a calculator for line item adjustment benefits. 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 SolidusPromotions
+  module Calculators
+    class DistributedAmount < Spree::Calculator
+      include PromotionCalculator
+
+      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?
+
+        distributable_line_items = calculable.applicable_line_items(line_item.order)
+        return 0 unless line_item.in?(distributable_line_items)
+
+        DistributedAmountsHandler.new(
+          distributable_line_items,
+          preferred_amount
+        ).amount(line_item)
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/calculators/flat_rate.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_dependency "spree/calculator"
+
+module SolidusPromotions
+  module Calculators
+    class FlatRate < Spree::Calculator
+      include PromotionCalculator
+
+      preference :amount, :decimal, default: 0
+      preference :currency, :string, default: -> { Spree::Config[:currency] }
+
+      def compute(object = nil)
+        currency = object.order.currency
+        if object && preferred_currency.casecmp(currency).zero?
+          preferred_amount
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/calculators/flexi_rate.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_dependency "spree/calculator"
+
+module SolidusPromotions
+  module Calculators
+    class FlexiRate < Spree::Calculator
+      include PromotionCalculator
+
+      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
+end

data/app/models/solidus_promotions/calculators/percent.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_dependency "spree/calculator"
+
+module SolidusPromotions
+  module Calculators
+    class Percent < Spree::Calculator
+      include PromotionCalculator
+
+      preference :percent, :decimal, default: 0
+
+      def compute(object)
+        preferred_currency = object.order.currency
+        currency_exponent = ::Money::Currency.find(preferred_currency).exponent
+        (object.discountable_amount * preferred_percent / 100).round(currency_exponent)
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/calculators/tiered_flat_rate.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_dependency "spree/calculator"
+
+module SolidusPromotions
+  module Calculators
+    class TieredFlatRate < Spree::Calculator
+      include PromotionCalculator
+
+      preference :base_amount, :decimal, default: 0
+      preference :tiers, :hash, default: { 10 => 10 }
+      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_item(object)
+        _base, amount = preferred_tiers.sort.reverse.detect do |value, _|
+          object.discountable_amount >= value
+        end
+
+        if preferred_currency.casecmp(object.currency).zero?
+          amount || preferred_base_amount
+        else
+          0
+        end
+      end
+      alias_method :compute_shipment, :compute_item
+      alias_method :compute_line_item, :compute_item
+
+      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
+end

data/app/models/solidus_promotions/calculators/tiered_percent.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_dependency "spree/calculator"
+
+module SolidusPromotions
+  module Calculators
+    class TieredPercent < Spree::Calculator
+      include PromotionCalculator
+
+      preference :base_percent, :decimal, default: 0
+      preference :tiers, :hash, default: { 50 => 5 }
+      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_item(object)
+        order = 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
+      alias_method :compute_shipment, :compute_item
+      alias_method :compute_line_item, :compute_item
+
+      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
+end

data/app/models/solidus_promotions/calculators/tiered_percent_on_eligible_item_quantity.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_dependency "spree/calculator"
+
+module SolidusPromotions
+  module Calculators
+    class TieredPercentOnEligibleItemQuantity < SolidusPromotions::Calculators::TieredPercent
+      preference :tiers, :hash, default: { 10 => 5 }
+
+      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|
+            [key.to_i, cast_to_d(value.to_s)]
+          end.to_h
+        end
+      end
+
+      def compute_line_item(line_item)
+        order = line_item.order
+
+        _base, percent = preferred_tiers.sort.reverse.detect do |value, _|
+          eligible_line_items_quantity_total(order) >= value
+        end
+        if preferred_currency.casecmp(order.currency).zero?
+          currency_exponent = ::Money::Currency.find(preferred_currency).exponent
+          (line_item.discountable_amount * (percent || preferred_base_percent) / 100).round(currency_exponent)
+        else
+          0
+        end
+      end
+
+      private
+
+      def eligible_line_items_quantity_total(order)
+        calculable.applicable_line_items(order).sum(&:quantity)
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/condition.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "spree/preferences/persistable"
+
+module SolidusPromotions
+  class Condition < Spree::Base
+    include Spree::Preferences::Persistable
+
+    belongs_to :benefit, class_name: "SolidusPromotions::Benefit", inverse_of: :conditions, optional: true
+    has_one :promotion, through: :benefit
+
+    scope :of_type, ->(type) { where(type: type) }
+
+    validate :unique_per_benefit, on: :create
+    validate :possible_condition_for_benefit, if: -> { benefit.present? }
+
+    def preload_relations
+      []
+    end
+
+    def applicable?(_promotable)
+      raise NotImplementedError, "applicable? should be implemented in a sub-class of SolidusPromotions::Rule"
+    end
+
+    def eligible?(_promotable, _options = {})
+      raise NotImplementedError, "eligible? should be implemented in a sub-class of SolidusPromotions::Rule"
+    end
+
+    def level
+      raise NotImplementedError, "level should be implemented in a sub-class of SolidusPromotions::Rule"
+    end
+
+    def eligibility_errors
+      @eligibility_errors ||= ActiveModel::Errors.new(self)
+    end
+
+    def to_partial_path
+      "solidus_promotions/admin/condition_fields/#{model_name.element}"
+    end
+
+    def updateable?
+      preferences.any?
+    end
+
+    private
+
+    def unique_per_benefit
+      return unless self.class.exists?(benefit_id: benefit_id, type: self.class.name)
+
+      errors.add(:benefit, :already_contains_condition_type)
+    end
+
+    def possible_condition_for_benefit
+      benefit.possible_conditions.include?(self.class) || errors.add(:type, :invalid_condition_type)
+    end
+
+    def eligibility_error_message(key, options = {})
+      I18n.t(key, scope: [:solidus_promotions, :eligibility_errors, self.class.name.underscore], **options)
+    end
+  end
+end

data/app/models/solidus_promotions/condition_product.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class ConditionProduct < Spree::Base
+    belongs_to :condition, class_name: "SolidusPromotions::Condition", optional: true
+    belongs_to :product, class_name: "Spree::Product", optional: true
+  end
+end

data/app/models/solidus_promotions/condition_store.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class ConditionStore < Spree::Base
+    belongs_to :condition, class_name: "SolidusPromotions::Condition", optional: true
+    belongs_to :store, class_name: "Spree::Store", optional: true
+  end
+end

data/app/models/solidus_promotions/condition_taxon.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class ConditionTaxon < Spree::Base
+    belongs_to :condition, class_name: "SolidusPromotions::Condition", optional: true
+    belongs_to :taxon, class_name: "Spree::Taxon", optional: true
+  end
+end

data/app/models/solidus_promotions/condition_user.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class ConditionUser < Spree::Base
+    belongs_to :condition, class_name: "SolidusPromotions::Condition", optional: true
+    belongs_to :user, class_name: Spree::UserClassHandle.new, optional: true
+  end
+end

data/app/models/solidus_promotions/conditions/discounted_item_total.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    # A condition to apply to an order greater than (or greater than or equal to)
+    # a specific amount after previous promotions have applied
+    #
+    # To add extra operators please override `self.operators_map` or any other helper method.
+    # To customize the error message you can also override `ineligible_message`.
+    class DiscountedItemTotal < ItemTotal
+      def to_partial_path
+        "solidus_promotions/admin/condition_fields/item_total"
+      end
+
+      private
+
+      def total_for_order(order)
+        order.discountable_item_total
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/first_order.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class FirstOrder < Condition
+      include OrderLevelCondition
+      attr_reader :user, :email
+
+      def eligible?(order, options = {})
+        @user = order.try(:user) || options[:user]
+        @email = order.email
+
+        if (user || email) && (completed_orders.present? && completed_orders.first != order)
+          eligibility_errors.add(:base, eligibility_error_message(:not_first_order), error_code: :not_first_order)
+        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

data/app/models/solidus_promotions/conditions/first_repeat_purchase_since.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class FirstRepeatPurchaseSince < Condition
+      include OrderLevelCondition
+
+      preference :days_ago, :integer, default: 365
+      validates :preferred_days_ago, numericality: { only_integer: true, greater_than: 0 }
+
+      # 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

data/app/models/solidus_promotions/conditions/item_total.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    # A condition to apply to an order greater than (or greater than or equal to)
+    # a specific amount
+    #
+    # To add extra operators please override `self.operators_map` or any other helper method.
+    # To customize the error message you can also override `ineligible_message`.
+    class ItemTotal < Condition
+      include OrderLevelCondition
+
+      preference :amount, :decimal, default: 100.00
+      preference :currency, :string, default: -> { Spree::Config[:currency] }
+      preference :operator, :string, default: "gt"
+
+      # The list of allowed operators names mapped to their symbols.
+      def self.operators_map
+        {
+          gte: :>=,
+          gt: :>
+        }
+      end
+
+      def self.operator_options
+        operators_map.map do |name, _method|
+          [I18n.t(name, scope: "solidus_promotions.item_total_condition.operators"), name]
+        end
+      end
+
+      def eligible?(order, _options = {})
+        return false unless order.currency == preferred_currency
+
+        unless total_for_order(order).send(operator, threshold)
+          eligibility_errors.add(:base, ineligible_message, error_code: ineligible_error_code)
+        end
+
+        eligibility_errors.empty?
+      end
+
+      private
+
+      def operator
+        self.class.operators_map.fetch(
+          preferred_operator.to_sym,
+          preferred_operator_default
+        )
+      end
+
+      def total_for_order(order)
+        order.item_total
+      end
+
+      def threshold
+        BigDecimal(preferred_amount.to_s)
+      end
+
+      def formatted_amount
+        Spree::Money.new(preferred_amount, currency: preferred_currency).to_s
+      end
+
+      def ineligible_message
+        eligibility_error_message(ineligible_error_code, amount: formatted_amount)
+      end
+
+      def ineligible_error_code
+        if preferred_operator == "gte"
+          :item_total_less_than
+        else
+          :item_total_less_than_or_equal
+        end
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/line_item_option_value.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    class LineItemOptionValue < Condition
+      include LineItemLevelCondition
+
+      preference :eligible_values, :hash
+
+      def eligible?(line_item, _options = {})
+        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] || {}
+        values.keys.map(&:to_i).zip(
+          values.values.map do |value|
+            (value.is_a?(Array) ? value : value.split(",")).map(&:to_i)
+          end
+        ).to_h
+      end
+
+      private
+
+      def product_ids
+        preferred_eligible_values.keys
+      end
+
+      def value_ids(product_id)
+        preferred_eligible_values[product_id]
+      end
+    end
+  end
+end

data/app/models/solidus_promotions/conditions/line_item_product.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    # A condition to apply a promotion only to line items with or without a chosen product
+    class LineItemProduct < Condition
+      include LineItemLevelCondition
+
+      MATCH_POLICIES = %w[include exclude].freeze
+
+      has_many :condition_products,
+        dependent: :destroy,
+        foreign_key: :condition_id,
+        class_name: "SolidusPromotions::ConditionProduct"
+      has_many :products,
+        class_name: "Spree::Product",
+        through: :condition_products
+
+      preference :match_policy, :string, default: MATCH_POLICIES.first
+
+      def preload_relations
+        [:products]
+      end
+
+      def eligible?(line_item, _options = {})
+        order_includes_product = product_ids.include?(line_item.variant.product_id)
+        success = inverse? ? !order_includes_product : order_includes_product
+
+        unless success
+          message_code = inverse? ? :has_excluded_product : :no_applicable_products
+          eligibility_errors.add(
+            :base,
+            eligibility_error_message(message_code),
+            error_code: message_code
+          )
+        end
+
+        success
+      end
+
+      def product_ids_string
+        product_ids.join(",")
+      end
+
+      def product_ids_string=(product_ids)
+        self.product_ids = product_ids.to_s.split(",").map(&:strip)
+      end
+
+      private
+
+      def inverse?
+        preferred_match_policy == "exclude"
+      end
+    end
+  end
+end