solidus_friendly_promotions 1.0.0.pre

data/app/models/solidus_friendly_promotions/distributed_amounts_handler.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class DistributedAmountsHandler
+    attr_reader :line_items, :total_amount
+
+    def initialize(line_items, total_amount)
+      @line_items = line_items
+      @total_amount = total_amount
+    end
+
+    # @param line_item [LineItem] one of the line_items distributed over
+    # @return [BigDecimal] the weighted adjustment for this line_item
+    def amount(line_item)
+      distributed_amounts[line_item.id].to_d
+    end
+
+    private
+
+    # @private
+    # @return [Hash<Integer, BigDecimal>] a hash of line item IDs and their
+    #   corresponding weighted adjustments
+    def distributed_amounts
+      line_item_ids.zip(allocated_amounts).to_h
+    end
+
+    def line_item_ids
+      line_items.map(&:id)
+    end
+
+    def elligible_amounts
+      line_items.map(&:discountable_amount)
+    end
+
+    def subtotal
+      elligible_amounts.sum
+    end
+
+    def allocated_amounts
+      total_amount.to_money.allocate(elligible_amounts).map(&:to_money)
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/eligibility_result.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  EligibilityResult = Struct.new(:item, :rule, :success, :code, :message, keyword_init: true)
+end

data/app/models/solidus_friendly_promotions/eligibility_results.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class EligibilityResults
+    include Enumerable
+    attr_reader :results, :promotion
+    def initialize(promotion)
+      @promotion = promotion
+      @results = []
+    end
+
+    def add(item:, rule:, success:, code:, message:)
+      results << EligibilityResult.new(
+        item: item,
+        rule: rule,
+        success: success,
+        code: code,
+        message: message
+      )
+    end
+
+    def success?
+      return true if results.empty?
+      promotion.actions.any? do |action|
+        action.relevant_rules.all? do |rule|
+          results_for_rule = results.select { |result| result.rule == rule }
+          results_for_rule.any?(&:success)
+        end
+      end
+    end
+
+    def error_messages
+      return [] if results.empty?
+      results.group_by(&:rule).map do |rule, results|
+        next if results.any?(&:success)
+        results.detect { |r| !r.success }&.message
+      end.compact
+    end
+
+    def each(&block)
+      results.each(&block)
+    end
+
+    def last
+      results.last
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/friendly_promotion_adjuster/choose_discounts.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class FriendlyPromotionAdjuster
+    class ChooseDiscounts
+      attr_reader :discounts
+
+      def initialize(discounts)
+        @discounts = discounts
+      end
+
+      def call
+        Array.wrap(
+          discounts.min_by do |discount|
+            [discount.amount, -discount.source&.id.to_i]
+          end
+        )
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/friendly_promotion_adjuster/discount_order.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class FriendlyPromotionAdjuster
+    class DiscountOrder
+      attr_reader :order, :promotions, :dry_run
+
+      def initialize(order, promotions, dry_run: false)
+        @order = order
+        @promotions = promotions
+        @dry_run = dry_run
+      end
+
+      def call
+        return order if order.shipped?
+
+        SolidusFriendlyPromotions::Promotion.ordered_lanes.each do |lane, _index|
+          lane_promotions = eligible_promotions_for_promotable(promotions.select { |promotion| promotion.lane == lane }, order)
+          line_item_discounts = adjust_line_items(lane_promotions)
+          shipment_discounts = adjust_shipments(lane_promotions)
+          shipping_rate_discounts = adjust_shipping_rates(lane_promotions)
+          (line_item_discounts + shipment_discounts + shipping_rate_discounts).each do |item, chosen_discounts|
+            item.current_discounts.concat(chosen_discounts)
+          end
+        end
+
+        order
+      end
+
+      private
+
+      def adjust_line_items(promotions)
+        order.line_items.select do |line_item|
+          line_item.variant.product.promotionable?
+        end.map do |line_item|
+          discounts = generate_discounts(promotions, line_item)
+          chosen_item_discounts = SolidusFriendlyPromotions.config.discount_chooser_class.new(discounts).call
+          [line_item, chosen_item_discounts]
+        end
+      end
+
+      def adjust_shipments(promotions)
+        order.shipments.map do |shipment|
+          discounts = generate_discounts(promotions, shipment)
+          chosen_item_discounts = SolidusFriendlyPromotions.config.discount_chooser_class.new(discounts).call
+          [shipment, chosen_item_discounts]
+        end
+      end
+
+      def adjust_shipping_rates(promotions)
+        order.shipments.flat_map(&:shipping_rates).select(&:cost).map do |rate|
+          discounts = generate_discounts(promotions, rate)
+          chosen_item_discounts = SolidusFriendlyPromotions.config.discount_chooser_class.new(discounts).call
+          [rate, chosen_item_discounts]
+        end
+      end
+
+      def eligible_promotions_for_promotable(possible_promotions, promotable)
+        possible_promotions.select do |candidate|
+          candidate.eligible_by_applicable_rules?(promotable, dry_run: dry_run)
+        end
+      end
+
+      def generate_discounts(possible_promotions, item)
+        eligible_promotions = eligible_promotions_for_promotable(possible_promotions, item)
+        eligible_promotions.flat_map do |promotion|
+          promotion.actions.select do |action|
+            action.can_discount?(item)
+          end.map do |action|
+            action.discount(item)
+          end.compact
+        end
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/friendly_promotion_adjuster/load_promotions.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class FriendlyPromotionAdjuster
+    class LoadPromotions
+      def initialize(order:, dry_run_promotion: nil)
+        @order = order
+        @dry_run_promotion = dry_run_promotion
+      end
+
+      def call
+        promos = connected_order_promotions | sale_promotions
+        promos << dry_run_promotion if dry_run_promotion
+        promos.flat_map(&:actions).group_by(&:preload_relations).each do |preload_relations, actions|
+          preload(records: actions, associations: preload_relations)
+        end
+        promos.flat_map(&:rules).group_by(&:preload_relations).each do |preload_relations, rules|
+          preload(records: rules, associations: preload_relations)
+        end
+        promos.reject { |promotion| promotion.usage_limit_exceeded?(excluded_orders: [order]) }
+      end
+
+      private
+
+      attr_reader :order, :dry_run_promotion
+
+      def preload(records:, associations:)
+        ActiveRecord::Associations::Preloader.new(records: records, associations: associations).call
+      end
+
+      def connected_order_promotions
+        eligible_connected_promotion_ids = order.friendly_order_promotions.select do |order_promotion|
+          order_promotion.promotion_code.nil? || !order_promotion.promotion_code.usage_limit_exceeded?(excluded_orders: [order])
+        end.map(&:promotion_id)
+        order.friendly_promotions.active(reference_time).where(id: eligible_connected_promotion_ids).includes(promotion_includes)
+      end
+
+      def sale_promotions
+        SolidusFriendlyPromotions::Promotion.where(apply_automatically: true).active(reference_time).includes(promotion_includes)
+      end
+
+      def reference_time
+        order.completed_at || Time.current
+      end
+
+      def promotion_includes
+        [
+          :rules,
+          :actions
+        ]
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/friendly_promotion_adjuster/persist_discounted_order.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class FriendlyPromotionAdjuster
+    class PersistDiscountedOrder
+      def initialize(order)
+        @order = order
+      end
+
+      def call
+        order.line_items.each do |line_item|
+          update_adjustments(line_item, line_item.current_discounts)
+        end
+
+        order.shipments.each do |shipment|
+          update_adjustments(shipment, shipment.current_discounts)
+        end
+
+        order.shipments.flat_map(&:shipping_rates).each do |shipping_rate|
+          shipping_rate.discounts = shipping_rate.current_discounts.map do |discount|
+            SolidusFriendlyPromotions::ShippingRateDiscount.create!(
+              shipping_rate: shipping_rate,
+              amount: discount.amount,
+              label: discount.label,
+              promotion_action: discount.source
+            )
+          end
+        end
+        order.reset_current_discounts
+        order.promo_total = (order.line_items + order.shipments).sum(&:promo_total)
+        order
+      end
+
+      private
+
+      attr_reader :order
+
+      # Walk through the discounts for an item and update adjustments for it. Once
+      # all of the discounts have been added as adjustments, remove any old tax
+      # adjustments that weren't touched.
+      #
+      # @private
+      # @param [#adjustments] item a {Spree::LineItem} or {Spree::Shipment}
+      # @param [Array<SolidusFriendlyPromotions::ItemDiscount>] item_discounts a list of calculated discounts for an item
+      # @return [void]
+      def update_adjustments(item, item_discounts)
+        promotion_adjustments = item.adjustments.select(&:promotion?)
+
+        active_adjustments = item_discounts.map do |item_discount|
+          update_adjustment(item, item_discount)
+        end
+        item.update(promo_total: active_adjustments.sum(&:amount))
+        # Remove any tax adjustments tied to promotion actions which no longer match.
+        unmatched_adjustments = promotion_adjustments - active_adjustments
+
+        item.adjustments.destroy(unmatched_adjustments)
+      end
+
+      # Update or create a new tax adjustment on an item.
+      #
+      # @private
+      # @param [#adjustments] item a {Spree::LineItem} or {Spree::Shipment}
+      # @param [SolidusFriendlyPromotions::ItemDiscount] tax_item calculated discounts for an item
+      # @return [Spree::Adjustment] the created or updated tax adjustment
+      def update_adjustment(item, discount_item)
+        adjustment = item.adjustments.detect do |item_adjustment|
+          item_adjustment.source == discount_item.source
+        end
+
+        adjustment ||= item.adjustments.new(
+          source: discount_item.source,
+          order_id: item.is_a?(Spree::Order) ? item.id : item.order_id,
+          label: discount_item.label,
+          eligible: true
+        )
+        adjustment.update!(amount: discount_item.amount)
+        adjustment
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/friendly_promotion_adjuster.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class FriendlyPromotionAdjuster
+    attr_reader :order, :promotions, :dry_run
+
+    def initialize(order, dry_run_promotion: nil)
+      @order = order
+      @dry_run = !!dry_run_promotion
+      @promotions = LoadPromotions.new(order: order, dry_run_promotion: dry_run_promotion).call
+    end
+
+    def call
+      order.reset_current_discounts
+
+      return order if order.shipped?
+      discounted_order = DiscountOrder.new(order, promotions, dry_run: dry_run).call
+
+      PersistDiscountedOrder.new(discounted_order).call unless dry_run
+
+      order.reset_current_discounts
+      order
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/item_discount.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  # Simple object used to hold discount data for an item.
+  #
+  # This generic object will hold the amount of discount that should be applied to
+  # an item.
+  #
+  # @attr_reader [Spree::LineItem,Spree::Shipment] the item to be discounted.
+  # @attr_reader [String] label information about the discount
+  # @attr_reader [ApplicationRecord] source will be used as the source for adjustments
+  # @attr_reader [BigDecimal] amount the amount of discount applied to the item
+  class ItemDiscount
+    include ActiveModel::Model
+    attr_accessor :item, :label, :source, :amount
+
+    def ==(other)
+      item == other.item && label == other.label && source == other.source && amount == other.amount
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/migration_support/order_promotion_syncer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module MigrationSupport
+    class OrderPromotionSyncer
+      attr_reader :order
+
+      def initialize(order:)
+        @order = order
+      end
+
+      def call
+        sync_spree_order_promotions_to_friendly_order_promotions
+        sync_friendly_order_promotions_to_spree_order_promotions
+      end
+
+      private
+
+      def sync_spree_order_promotions_to_friendly_order_promotions
+        order.order_promotions.each do |spree_order_promotion|
+          friendly_promotion = SolidusFriendlyPromotions::Promotion.find_by(
+            original_promotion_id: spree_order_promotion.promotion.id
+          )
+          next unless friendly_promotion
+          if spree_order_promotion.promotion_code
+            friendly_promotion_code = friendly_promotion.codes.find_by(
+              value: spree_order_promotion.promotion_code.value
+            )
+          end
+          order.friendly_order_promotions.find_or_create_by!(
+            promotion: friendly_promotion,
+            promotion_code: friendly_promotion_code
+          )
+        end
+      end
+
+      def sync_friendly_order_promotions_to_spree_order_promotions
+        order.friendly_order_promotions.each do |friendly_order_promotion|
+          spree_promotion = friendly_order_promotion.promotion.original_promotion
+          next unless spree_promotion
+          if friendly_order_promotion.promotion_code
+            spree_promotion_code = spree_promotion.promotion_codes.find_by(
+              value: friendly_order_promotion.promotion_code.value
+            )
+          end
+          order.order_promotions.find_or_create_by!(
+            promotion: spree_promotion,
+            promotion_code: spree_promotion_code
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/order_promotion.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  # SolidusFriendlyPromotions::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
+    belongs_to :order, class_name: "Spree::Order"
+    belongs_to :promotion, class_name: "SolidusFriendlyPromotions::Promotion"
+    belongs_to :promotion_code, class_name: "SolidusFriendlyPromotions::PromotionCode", optional: 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/solidus_friendly_promotions/permission_sets/friendly_promotion_management.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module PermissionSets
+    class FriendlyPromotionManagement < Spree::PermissionSets::Base
+      def activate!
+        can :manage, SolidusFriendlyPromotions::Promotion
+        can :manage, SolidusFriendlyPromotions::PromotionRule
+        can :manage, SolidusFriendlyPromotions::PromotionAction
+        can :manage, SolidusFriendlyPromotions::PromotionCategory
+        can :manage, SolidusFriendlyPromotions::PromotionCode
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/products_promotion_rule.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class ProductsPromotionRule < Spree::Base
+    belongs_to :product, class_name: "Spree::Product", optional: true
+    belongs_to :promotion_rule, class_name: "SolidusFriendlyPromotions::PromotionRule", optional: true
+  end
+end

data/app/models/solidus_friendly_promotions/promotion.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class Promotion < Spree::Base
+    belongs_to :category, class_name: "SolidusFriendlyPromotions::PromotionCategory",
+      foreign_key: :promotion_category_id, optional: true
+    belongs_to :original_promotion, class_name: "Spree::Promotion", optional: true
+    has_many :rules, class_name: "SolidusFriendlyPromotions::PromotionRule", dependent: :destroy
+    has_many :actions, class_name: "SolidusFriendlyPromotions::PromotionAction", dependent: :nullify
+    has_many :codes, class_name: "SolidusFriendlyPromotions::PromotionCode", dependent: :destroy
+    has_many :code_batches, class_name: "SolidusFriendlyPromotions::PromotionCodeBatch", dependent: :destroy
+    has_many :order_promotions, class_name: "SolidusFriendlyPromotions::OrderPromotion", dependent: :destroy
+
+    validates :name, :customer_label, presence: true
+    validates :path, uniqueness: {allow_blank: true, case_sensitive: true}
+    validates :usage_limit, numericality: {greater_than: 0, allow_nil: true}
+    validates :per_code_usage_limit, numericality: {greater_than_or_equal_to: 0, allow_nil: true}
+    validates :description, length: {maximum: 255}
+    validate :apply_automatically_disallowed_with_paths
+
+    scope :active, ->(time = Time.current) { has_actions.started_and_unexpired(time) }
+    scope :advertised, -> { where(advertise: true) }
+    scope :coupons, -> { joins(:codes).distinct }
+    scope :started_and_unexpired, ->(time = Time.current) do
+      table = arel_table
+
+      where(table[:starts_at].eq(nil).or(table[:starts_at].lt(time)))
+        .where(table[:expires_at].eq(nil).or(table[:expires_at].gt(time)))
+    end
+    scope :has_actions, -> do
+      joins(:actions).distinct
+    end
+
+    enum lane: SolidusFriendlyPromotions.config.preferred_lanes
+
+    def self.human_enum_name(enum_name, enum_value)
+      I18n.t("activerecord.attributes.#{model_name.i18n_key}.#{enum_name.to_s.pluralize}.#{enum_value}")
+    end
+
+    def self.lane_options
+      ordered_lanes.map do |lane_name, _index|
+        [human_enum_name(:lane, lane_name), lane_name]
+      end
+    end
+
+    def self.ordered_lanes
+      lanes.sort_by(&:last).to_h
+    end
+
+    self.allowed_ransackable_associations = ["codes"]
+    self.allowed_ransackable_attributes = %w[name path promotion_category_id]
+    self.allowed_ransackable_scopes = %i[active]
+
+    # All orders that have been discounted using this promotion
+    def discounted_orders
+      Spree::Order
+        .joins(:all_adjustments)
+        .where(
+          spree_adjustments: {
+            source_type: "SolidusFriendlyPromotions::PromotionAction",
+            source_id: actions.map(&:id),
+            eligible: true
+          }
+        ).distinct
+    end
+
+    # Number of times the code has been used overall
+    #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
+    # @return [Integer] usage count
+    def usage_count(excluded_orders: [])
+      discounted_orders
+        .complete
+        .where.not(id: [excluded_orders.map(&:id)])
+        .where.not(spree_orders: {state: :canceled})
+        .count
+    end
+
+    def used_by?(user, excluded_orders = [])
+      discounted_orders
+        .complete
+        .where.not(id: excluded_orders.map(&:id))
+        .where(user: user)
+        .where.not(spree_orders: {state: :canceled})
+        .exists?
+    end
+
+    # Whether the promotion has exceeded its usage restrictions.
+    #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage limit
+    # @return true or false
+    def usage_limit_exceeded?(excluded_orders: [])
+      return unless usage_limit
+
+      usage_count(excluded_orders: excluded_orders) >= usage_limit
+    end
+
+    def not_expired?(time = Time.current)
+      !expired?(time)
+    end
+
+    def not_started?(time = Time.current)
+      !started?(time)
+    end
+
+    def started?(time = Time.current)
+      starts_at.nil? || starts_at < time
+    end
+
+    def active?(time = Time.current)
+      started?(time) && not_expired?(time) && actions.present?
+    end
+
+    def inactive?(time = Time.current)
+      !active?(time)
+    end
+
+    def expired?(time = Time.current)
+      expires_at.present? && expires_at < time
+    end
+
+    def products
+      rules.where(type: "SolidusFriendlyPromotions::Rules::Product").flat_map(&:products).uniq
+    end
+
+    def eligibility_results
+      @eligibility_results ||= SolidusFriendlyPromotions::EligibilityResults.new(self)
+    end
+
+    def eligible_by_applicable_rules?(promotable, dry_run: false)
+      applicable_rules = rules.select do |rule|
+        rule.applicable?(promotable)
+      end
+
+      applicable_rules.map do |applicable_rule|
+        eligible = applicable_rule.eligible?(promotable)
+
+        break [false] if !eligible && !dry_run
+
+        if dry_run
+          if applicable_rule.eligibility_errors.details[:base].first
+            code = applicable_rule.eligibility_errors.details[:base].first[:error_code]
+            message = applicable_rule.eligibility_errors.full_messages.first
+          end
+          eligibility_results.add(
+            item: promotable,
+            rule: applicable_rule,
+            success: eligible,
+            code: eligible ? nil : (code || :coupon_code_unknown_error),
+            message: eligible ? nil : (message || I18n.t(:coupon_code_unknown_error, scope: [:solidus_friendly_promotions, :eligibility_errors]))
+          )
+        end
+
+        eligible
+      end.all?
+    end
+
+    private
+
+    def apply_automatically_disallowed_with_paths
+      return unless apply_automatically
+
+      errors.add(:apply_automatically, :disallowed_with_path) if path.present?
+    end
+  end
+end