solidus_promotions 4.4.0

data/app/javascript/backend/solidus_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-condition-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/backend/solidus_promotions/web_components/number_with_currency.js

@@ -0,0 +1,35 @@
+class NumberWithCurrency extends HTMLElement {
+  connectedCallback() {
+    this.currencySelector = this.querySelector('.number-with-currency-select');
+    this.render()
+    this.addEventListener('change', this);
+  }
+
+  handleEvent() {
+    this.render()
+  }
+
+  get currency() {
+    if (this.currencySelector) {
+      return this.currencySelector.value;
+    } else {
+      return this.querySelector('.number-with-currency-addon')?.dataset?.currency;
+    }
+  }
+
+  get currencySymbol() {
+    const currency = this.currency;
+    if (currency) {
+      const currencyInfo = Spree.currencyInfo[currency];
+      return currencyInfo[0];
+    } else {
+      return '';
+    }
+  }
+
+  render() {
+    this.querySelector('.number-with-currency-symbol').textContent = this.currencySymbol;
+  }
+}
+
+customElements.define('number-with-currency', NumberWithCurrency);

data/app/javascript/backend/solidus_promotions/web_components/option_value_picker.js

@@ -0,0 +1,52 @@
+$.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
+  });
+};
+
+class OptionValuePicker extends HTMLInputElement {
+  connectedCallback() {
+    $(this).optionValueAutocomplete();
+  }
+}
+
+customElements.define('option-value-picker', OptionValuePicker, { extends: 'input' });

data/app/javascript/backend/solidus_promotions/web_components/product_picker.js

@@ -0,0 +1,7 @@
+class ProductPicker extends HTMLInputElement {
+  connectedCallback() {
+    $(this).productAutocomplete();
+  }
+}
+
+customElements.define('product-picker', ProductPicker, { extends: 'input' });

data/app/javascript/backend/solidus_promotions/web_components/select_two.js

@@ -0,0 +1,11 @@
+class SelectTwo extends HTMLSelectElement {
+  connectedCallback() {
+    $(this).select2({
+      allowClear: true,
+      dropdownAutoWidth: true,
+      minimumResultsForSearch: 8,
+    });
+  }
+}
+
+customElements.define("select-two", SelectTwo, { extends: "select" });

data/app/javascript/backend/solidus_promotions/web_components/taxon_picker.js

@@ -0,0 +1,7 @@
+class TaxonPicker extends HTMLInputElement {
+  connectedCallback() {
+    $(this).taxonAutocomplete();
+  }
+}
+
+customElements.define('taxon-picker', TaxonPicker, { extends: 'input' });

data/app/javascript/backend/solidus_promotions/web_components/user_picker.js

@@ -0,0 +1,7 @@
+class UserPicker extends HTMLInputElement {
+  connectedCallback() {
+    $(this).userAutocomplete();
+  }
+}
+
+customElements.define('user-picker', UserPicker, { extends: 'input' });

data/app/javascript/backend/solidus_promotions/web_components/variant_picker.js

@@ -0,0 +1,7 @@
+class VariantPicker extends HTMLInputElement {
+  connectedCallback() {
+    $(this).variantAutocomplete();
+  }
+}
+
+customElements.define('variant-picker', VariantPicker, { extends: 'input' });

data/app/javascript/backend/solidus_promotions.js

@@ -0,0 +1,11 @@
+import "@hotwired/turbo-rails";
+import "backend/solidus_promotions/controllers";
+import "backend/solidus_promotions/web_components/option_value_picker"
+import "backend/solidus_promotions/web_components/product_picker"
+import "backend/solidus_promotions/web_components/user_picker"
+import "backend/solidus_promotions/web_components/taxon_picker"
+import "backend/solidus_promotions/web_components/variant_picker"
+import "backend/solidus_promotions/web_components/number_with_currency"
+import "backend/solidus_promotions/web_components/select_two"
+
+Turbo.session.drive = false;

data/app/jobs/solidus_promotions/promotion_code_batch_job.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class PromotionCodeBatchJob < ActiveJob::Base
+    queue_as :default
+
+    def perform(promotion_code_batch)
+      PromotionCode::BatchBuilder.new(
+        promotion_code_batch
+      ).build_promotion_codes
+
+      if promotion_code_batch.email?
+        SolidusPromotions.config.promotion_code_batch_mailer_class
+          .promotion_code_batch_finished(promotion_code_batch)
+          .deliver_now
+      end
+    rescue StandardError => e
+      if promotion_code_batch.email?
+        SolidusPromotions.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_promotions/promotion_code_batch_mailer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  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_promotions/benefits/line_item_benefit.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Benefits
+    module LineItemBenefit
+      def can_discount?(object)
+        object.is_a? Spree::LineItem
+      end
+
+      def level
+        :line_item
+      end
+    end
+  end
+end

data/app/models/concerns/solidus_promotions/benefits/order_benefit.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Benefits
+    module OrderBenefit
+      def can_discount?(_)
+        false
+      end
+
+      def level
+        :order
+      end
+    end
+  end
+end

data/app/models/concerns/solidus_promotions/benefits/shipment_benefit.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Benefits
+    module ShipmentBenefit
+      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/concerns/solidus_promotions/calculators/promotion_calculator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Calculators
+    module PromotionCalculator
+      def description
+        self.class.human_attribute_name(:description)
+      end
+    end
+  end
+end

data/app/models/concerns/solidus_promotions/conditions/line_item_applicable_order_level_condition.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Conditions
+    module LineItemApplicableOrderLevelCondition
+      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_promotions/conditions/line_item_level_condition.rb

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

data/app/models/concerns/solidus_promotions/conditions/order_level_condition.rb

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

data/app/models/concerns/solidus_promotions/conditions/shipment_level_condition.rb

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

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  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/solidus_promotions/benefit.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "spree/preferences/persistable"
+
+module SolidusPromotions
+  # Base class for all types of benefit.
+  #
+  # Benefits perform the necessary tasks when a promotion is activated
+  # by an event and determined to be eligible.
+  class Benefit < Spree::Base
+    include Spree::Preferences::Persistable
+    include Spree::CalculatedAdjustments
+    include Spree::AdjustmentSource
+    before_destroy :remove_adjustments_from_incomplete_orders
+    before_destroy :raise_for_adjustments_for_completed_orders
+
+    belongs_to :promotion, inverse_of: :benefits
+    belongs_to :original_promotion_action, class_name: "Spree::PromotionAction", optional: true
+    has_many :adjustments, class_name: "Spree::Adjustment", as: :source
+    has_many :shipping_rate_discounts, class_name: "SolidusPromotions::ShippingRateDiscount", inverse_of: :benefit
+    has_many :conditions, class_name: "SolidusPromotions::Condition", inverse_of: :benefit, dependent: :destroy
+
+    scope :of_type, ->(type) { where(type: Array.wrap(type).map(&:to_s)) }
+
+    def preload_relations
+      [:calculator]
+    end
+
+    def can_discount?(object)
+      raise NotImplementedError, "Please implement the correct interface, or include one of the `SolidusPromotions::Benefits::OrderBenefit`, " \
+        "`SolidusPromotions::Benefits::LineItemBenefit` or `SolidusPromotions::Benefits::ShipmentBenefit` modules"
+    end
+
+    def discount(adjustable)
+      amount = compute_amount(adjustable)
+      return if amount.zero?
+      ItemDiscount.new(
+        item: adjustable,
+        label: adjustment_label(adjustable),
+        amount: amount,
+        source: self
+      )
+    end
+
+    # Ensure a negative amount which does not exceed the object's amount
+    def compute_amount(adjustable)
+      promotion_amount = calculator.compute(adjustable) || BigDecimal("0")
+      [adjustable.discountable_amount, promotion_amount.abs].min * -1
+    end
+
+    def adjustment_label(adjustable)
+      I18n.t(
+        "solidus_promotions.adjustment_labels.#{adjustable.class.name.demodulize.underscore}",
+        promotion: SolidusPromotions::Promotion.model_name.human,
+        promotion_customer_label: promotion.customer_label
+      )
+    end
+
+    def to_partial_path
+      "solidus_promotions/admin/benefit_fields/#{model_name.element}"
+    end
+
+    def level
+      raise NotImplementedError, "Please implement the correct interface, or include one of the `SolidusPromotions::Benefits::OrderBenefit`, " \
+        "`SolidusPromotions::Benefits::LineItemBenefit` or `SolidusPromotions::Benefits::ShipmentBenefit` modules"
+    end
+
+    def available_conditions
+      possible_conditions - conditions.select(&:persisted?)
+    end
+
+    def available_calculators
+      SolidusPromotions.config.promotion_calculators[self.class] || []
+    end
+
+    def eligible_by_applicable_conditions?(promotable, dry_run: false)
+      applicable_conditions = conditions.select do |condition|
+        condition.applicable?(promotable)
+      end
+
+      applicable_conditions.map do |applicable_condition|
+        eligible = applicable_condition.eligible?(promotable)
+
+        break [false] if !eligible && !dry_run
+
+        if dry_run
+          if applicable_condition.eligibility_errors.details[:base].first
+            code = applicable_condition.eligibility_errors.details[:base].first[:error_code]
+            message = applicable_condition.eligibility_errors.full_messages.first
+          end
+          promotion.eligibility_results.add(
+            item: promotable,
+            condition: applicable_condition,
+            success: eligible,
+            code: eligible ? nil : (code || :coupon_code_unknown_error),
+            message: eligible ? nil : (message || I18n.t(:coupon_code_unknown_error, scope: [:solidus_promotions, :eligibility_errors]))
+          )
+        end
+
+        eligible
+      end.all?
+    end
+
+    def applicable_line_items(order)
+      order.discountable_line_items.select do |line_item|
+        eligible_by_applicable_conditions?(line_item)
+      end
+    end
+
+    def possible_conditions
+      Set.new(SolidusPromotions.config.order_conditions)
+    end
+
+    private
+
+    def raise_for_adjustments_for_completed_orders
+      if adjustments.joins(:order).merge(Spree::Order.complete).any?
+        errors.add(:base, :cannot_destroy_if_order_completed)
+        throw(:abort)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Benefits
+    class AdjustLineItem < Benefit
+      include SolidusPromotions::Benefits::LineItemBenefit
+
+      def possible_conditions
+        super + SolidusPromotions.config.line_item_conditions
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Benefits
+    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 conditions 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 = applicable_line_items(order)
+
+        item_units = line_items.sort_by do |applicable_line_item|
+          [-applicable_line_item.quantity, applicable_line_item.id]
+        end.flat_map do |applicable_line_item|
+          Array.new(applicable_line_item.quantity) do
+            Item.new(applicable_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
+
+      ##
+      # 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_promotions/benefits/adjust_shipment.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  module Benefits
+    class AdjustShipment < Benefit
+      include SolidusPromotions::Benefits::ShipmentBenefit
+
+      def possible_conditions
+        super + SolidusPromotions.config.shipment_conditions
+      end
+    end
+  end
+end