wip

Author: mamhoff

promotions/app/models/solidus_promotions/product_discounter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class ProductDiscounter
+    attr_reader :order, :product, :pricing_options, :promotions, :quantity
+
+    def initialize(product:, order:, pricing_options:, quantity: 1)
+      @product = product
+      @order = order
+      @pricing_options = pricing_options
+      @quantity = quantity
+      @promotions = SolidusPromotions::OrderAdjuster::LoadPromotions.new(order:).call
+    end
+
+    def call
+      if product.has_variants?
+        product.variants.each { |variant| discount_variant(variant) }
+      else
+        discount_variant(product.master)
+      end
+    end
+
+    private
+
+    def discount_variant(variant)
+      variant.discountable_price = variant.price_for_options(pricing_options)
+
+      return unless variant.product.promotionable?
+
+      SolidusPromotions::Promotion.ordered_lanes.each_key do |lane|
+        lane_promotions = promotions.select { |promotion| promotion.lane == lane }
+        lane_benefits = eligible_benefits_for_promotable(lane_promotions.flat_map(&:benefits), order)
+        discounts = generate_discounts(lane_benefits, variant.discountable_price)
+        chosen_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
+        variant.discountable_price.current_discounts.concat(chosen_discounts)
+      end
+    end
+
+    def eligible_benefits_for_promotable(possible_benefits, promotable)
+      possible_benefits.select do |candidate|
+        candidate.eligible_by_applicable_conditions?(promotable)
+      end
+    end
+
+    def generate_discounts(possible_benefits, item)
+      eligible_benefits = eligible_benefits_for_promotable(possible_benefits, item)
+      eligible_benefits.select do |benefit|
+        benefit.can_discount?(item)
+      end.map do |benefit|
+        benefit.discount(item, order:, quantity:)
+      end.compact
+    end
+  end
+end

promotions/app/patches/models/solidus_promotions/variant_patch.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module VariantPatch
+    class VariantNotDiscounted < StandardError; end
+    attr_accessor :discountable_price
+
+    def self.prepended(base)
+      base.extend Spree::DisplayMoney
+
+      base.money_methods :discounted_price, :undiscounted_price
+    end
+
+    def undiscounted_price
+      raise VariantNotDiscounted unless discountable_price
+      discountable_price.amount
+    end
+
+    def discounted_price
+      raise VariantNotDiscounted unless discountable_price
+      discountable_price.discountable_amount
+    end
+
+    def price_discounts
+      raise VariantNotDiscounted unless discountable_price
+      discountable_price.current_discounts
+    end
+
+    Spree::Variant.prepend self
+  end
+end

promotions/spec/models/solidus_promotions/product_discounter_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe SolidusPromotions::ProductDiscounter do
+  subject do
+    described_class.new(product:, order:, pricing_options:).call
+  end
+
+  let(:product) { create(:product) }
+  let(:order) { create(:order) }
+  let(:pricing_options) do
+    Spree::Variant::PricingOptions.new
+  end
+
+  let!(:promotion) { create(:solidus_promotion, :with_adjustable_benefit, apply_automatically: true) }
+
+  it "applies a discount to the product's price" do
+    expect { product.discounted_price }.to raise_exception(SolidusPromotions::VariantPatch::VariantNotDiscounted)
+    subject
+    # Standard benefit calculator is a flat 10 USD off
+    expect(product.discounted_price).to eq(9.99)
+    expect(product.price_discounts.map(&:label)).to include("Promotion (Because we like you)")
+  end
+end