solidus_friendly_promotions 1.0.0.pre

data/app/javascript/solidus_friendly_promotions/controllers/index.js

@@ -0,0 +1,8 @@
+import { application } from "solidus_friendly_promotions/controllers/application";
+
+// Eager load all controllers defined in the import map under controllers/**/*_controller
+import { eagerLoadControllersFrom } from "@hotwired/stimulus-loading";
+eagerLoadControllersFrom(
+  "solidus_friendly_promotions/controllers",
+  application
+);

data/app/javascript/solidus_friendly_promotions/controllers/product_option_values_controller.js

@@ -0,0 +1,62 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  static targets = ["links", "template"];
+
+  connect() {
+    this.wrapperClass =
+      this.data.get("wrapperClass") || "promo-rule-option-value";
+
+    this.element.querySelectorAll("." + this.wrapperClass).forEach((element) => this.buildSelects(element))
+  }
+
+  add_row(event) {
+    event.preventDefault();
+
+    var content = this.templateTarget.innerHTML;
+    this.linksTarget.insertAdjacentHTML("beforebegin", content);
+    this.buildSelects(this.linksTarget.previousElementSibling)
+  }
+
+  propagate_product_id_to_value_input(event) {
+    event.preventDefault();
+    // targets the content of the last pair of square brackets
+    // we first need to greedily match all other square brackets
+    const regEx = /(\[.*\])\[.*?\]$/;
+    let wrapper = event.target.closest("." + this.wrapperClass);
+    let optionValuesInput = wrapper.querySelector(".option-values-select[type='hidden']");
+    optionValuesInput.name = optionValuesInput.name.replace(
+      regEx,
+      `$1[${event.target.value}]`
+    );
+  }
+
+  remove_row(event) {
+    event.preventDefault();
+
+    let wrapper = event.target.closest("." + this.wrapperClass);
+    wrapper.remove();
+  }
+
+  // helper functions
+
+  buildSelects(wrapper) {
+    let productSelect = wrapper.querySelector(".product-select")
+    let optionValueSelect = wrapper.querySelector(".option-values-select[type='hidden']")
+    this.buildProductSelect(productSelect)
+    $(optionValueSelect).optionValueAutocomplete({ productSelect });
+  }
+
+  buildProductSelect(productSelect) {
+    var jQueryProductSelect = $(productSelect)
+    jQueryProductSelect.productAutocomplete({
+      multiple: false,
+    })
+    // capture the jQuery "change" event and re-emit it as DOM event "select2Change"
+    // so that Stimulus can capture it
+    jQueryProductSelect.on('change', function () {
+      let event = new Event('select2Change', { bubbles: true }) // fire a native event
+      productSelect.dispatchEvent(event);
+    });
+  }
+}

data/app/javascript/solidus_friendly_promotions/jquery/option_value_picker.js

@@ -0,0 +1,44 @@
+$.fn.optionValueAutocomplete = function (options) {
+  'use strict';
+
+  // Default options
+  options = options || {}
+  var multiple = typeof(options['multiple']) !== 'undefined' ? options['multiple'] : true;
+  var productSelect = options['productSelect'];
+
+  function formatOptionValue(option_value) {
+    return Select2.util.escapeMarkup(option_value.name);
+  }
+
+  this.select2({
+    minimumInputLength: 3,
+    multiple: multiple,
+    initSelection: function (element, callback) {
+      $.get(Spree.pathFor('api/option_values'), {
+        ids: element.val().split(','),
+        token: Spree.api_key
+      }, function (data) {
+        callback(multiple ? data : data[0]);
+      });
+    },
+    ajax: {
+      url: Spree.pathFor('api/option_values'),
+      datatype: 'json',
+      data: function (term, page) {
+        var productId = typeof(productSelect) !== 'undefined' ? $(productSelect).select2('val') : null;
+        return {
+          q: {
+            name_cont: term,
+            variants_product_id_eq: productId
+          },
+          token: Spree.api_key
+        };
+      },
+      results: function (data, page) {
+        return { results: data };
+      }
+    },
+    formatResult: formatOptionValue,
+    formatSelection: formatOptionValue
+  });
+};

data/app/javascript/solidus_friendly_promotions.js

@@ -0,0 +1,12 @@
+import "@hotwired/turbo-rails";
+import "solidus_friendly_promotions/controllers";
+import "solidus_friendly_promotions/jquery/option_value_picker"
+
+Turbo.session.drive = false;
+
+document.addEventListener("turbo:frame-load", ({ _target }) => {
+  Spree.initNumberWithCurrency();
+  $(".product_picker").productAutocomplete();
+  $(".user_picker").userAutocomplete();
+  $(".taxon_picker").taxonAutocomplete();
+});

data/app/jobs/solidus_friendly_promotions/promotion_code_batch_job.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class PromotionCodeBatchJob < ApplicationJob
+    queue_as :default
+
+    def perform(promotion_code_batch)
+      PromotionCode::BatchBuilder.new(
+        promotion_code_batch
+      ).build_promotion_codes
+
+      if promotion_code_batch.email?
+        SolidusFriendlyPromotions.config.promotion_code_batch_mailer_class
+          .promotion_code_batch_finished(promotion_code_batch)
+          .deliver_now
+      end
+    rescue => e
+      if promotion_code_batch.email?
+        SolidusFriendlyPromotions.config.promotion_code_batch_mailer_class
+          .promotion_code_batch_errored(promotion_code_batch)
+          .deliver_now
+      end
+      raise e
+    end
+  end
+end

data/app/mailers/solidus_friendly_promotions/promotion_code_batch_mailer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class PromotionCodeBatchMailer < Spree::BaseMailer
+    def promotion_code_batch_finished(promotion_code_batch)
+      @promotion_code_batch = promotion_code_batch
+      mail(to: promotion_code_batch.email)
+    end
+
+    def promotion_code_batch_errored(promotion_code_batch)
+      @promotion_code_batch = promotion_code_batch
+      mail(to: promotion_code_batch.email)
+    end
+  end
+end

data/app/models/concerns/solidus_friendly_promotions/discountable_amount.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module DiscountableAmount
+    def discountable_amount
+      amount + current_discounts.sum(&:amount)
+    end
+
+    def current_discounts
+      @current_discounts ||= []
+    end
+
+    def current_discounts=(args)
+      @current_discounts = args
+    end
+
+    def reset_current_discounts
+      @current_discounts = []
+    end
+  end
+end

data/app/models/concerns/solidus_friendly_promotions/rules/line_item_applicable_order_rule.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    module LineItemApplicableOrderRule
+      def self.included(klass)
+        klass.preference :line_item_applicable, :boolean, default: true
+      end
+
+      def applicable?(promotable)
+        promotable.is_a?(Spree::Order) || preferred_line_item_applicable && promotable.is_a?(Spree::LineItem)
+      end
+
+      def eligible?(promotable)
+        send("#{promotable.class.name.demodulize.underscore}_eligible?", promotable)
+      end
+
+      def level
+        :order
+      end
+    end
+  end
+end

data/app/models/concerns/solidus_friendly_promotions/rules/line_item_level_rule.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    module LineItemLevelRule
+      def applicable?(promotable)
+        promotable.is_a?(Spree::LineItem)
+      end
+
+      def level
+        :line_item
+      end
+    end
+  end
+end

data/app/models/concerns/solidus_friendly_promotions/rules/order_level_rule.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    module OrderLevelRule
+      def applicable?(promotable)
+        promotable.is_a?(Spree::Order)
+      end
+
+      def level
+        :order
+      end
+    end
+  end
+end

data/app/models/concerns/solidus_friendly_promotions/rules/shipment_level_rule.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Rules
+    module ShipmentLevelRule
+      def applicable?(promotable)
+        promotable.is_a?(Spree::Shipment)
+      end
+
+      def level
+        :shipment
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/actions/adjust_line_item.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Actions
+    class AdjustLineItem < PromotionAction
+      def can_discount?(object)
+        object.is_a? Spree::LineItem
+      end
+
+      def level
+        :line_item
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/actions/adjust_line_item_quantity_groups.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Actions
+    class AdjustLineItemQuantityGroups < AdjustLineItem
+      preference :group_size, :integer, default: 1
+
+      ##
+      # 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(Item.new(line_item))
+        return BigDecimal("0") if adjustment_amount.nil? || adjustment_amount.zero?
+
+        adjustment_amount = adjustment_amount.abs
+
+        order = line_item.order
+        line_items = actionable_line_items(order)
+
+        item_units = line_items.sort_by do |line_item|
+          [-line_item.quantity, line_item.id]
+        end.flat_map do |line_item|
+          Array.new(line_item.quantity) do
+            Item.new(line_item)
+          end
+        end
+
+        item_units_in_groups = item_units.in_groups_of(preferred_group_size, false)
+        item_units_in_groups.select! { |group| group.length == preferred_group_size }
+        usable_quantity = item_units_in_groups.flatten.count { |item_unit| item_unit.line_item == line_item }
+
+        amount = adjustment_amount * usable_quantity
+        [line_item.discountable_amount, amount].min * -1
+      end
+
+      private
+
+      def actionable_line_items(order)
+        order.line_items.select do |item|
+          promotion.rules.select do |rule|
+            rule.applicable?(item)
+          end.all? { |rule| rule.eligible?(item) }
+        end
+      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 Item
+        attr_reader :line_item
+        def initialize(line_item)
+          @line_item = line_item
+        end
+
+        def discountable_amount
+          @line_item.discountable_amount / @line_item.quantity.to_d
+        end
+        alias_method :amount, :discountable_amount
+
+        def order
+          @line_item.order
+        end
+
+        def currency
+          @line_item.currency
+        end
+      end
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/actions/adjust_shipment.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Actions
+    class AdjustShipment < PromotionAction
+      def can_discount?(object)
+        object.is_a?(Spree::Shipment) || object.is_a?(Spree::ShippingRate)
+      end
+
+      def level
+        :shipment
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_dependency "spree/calculator"
+
+# This is a calculator for line item adjustment actions. 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 SolidusFriendlyPromotions
+  module Calculators
+    class DistributedAmount < Spree::Calculator
+      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 = eligible_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
+
+      private
+
+      def eligible_line_items(order)
+        order.line_items.select do |line_item|
+          calculable.promotion.eligible_by_applicable_rules?(line_item)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_dependency "spree/calculator"
+
+module SolidusFriendlyPromotions
+  module Calculators
+    class FlatRate < Spree::Calculator
+      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_friendly_promotions/calculators/flexi_rate.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_dependency "spree/calculator"
+
+module SolidusFriendlyPromotions
+  module Calculators
+    class FlexiRate < Spree::Calculator
+      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_friendly_promotions/calculators/percent.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_dependency "spree/calculator"
+
+module SolidusFriendlyPromotions
+  module Calculators
+    class Percent < Spree::Calculator
+      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_friendly_promotions/calculators/tiered_flat_rate.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_dependency "spree/calculator"
+
+module SolidusFriendlyPromotions
+  module Calculators
+    class TieredFlatRate < Spree::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_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_friendly_promotions/calculators/tiered_percent.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_dependency "spree/calculator"
+
+module SolidusFriendlyPromotions
+  module Calculators
+    class TieredPercent < Spree::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_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