solidus_legacy_promotions 4.4.0

data/app/assets/javascripts/spree/backend/views/promotions/option_values_rule.js

@@ -0,0 +1,79 @@
+Spree.Views.Promotions.OptionValuesRuleRow = Backbone.View.extend({
+  optionValueTemplate: HandlebarsTemplates['promotions/rules/option_values'],
+
+  events: {
+    'click .js-remove-promo-rule-option-value': 'onRemove',
+    'change .js-promo-rule-option-value-product-select': 'onSelectProduct'
+  },
+
+  initialize: function(options) {
+    this.productId = options.productId;
+    this.values = options.values;
+    this.paramPrefix = options.paramPrefix;
+  },
+
+  render: function() {
+    this.$el.html(
+      this.optionValueTemplate({
+        productSelect: { value: this.productId },
+        optionValuesSelect: { value: this.values },
+        paramPrefix: this.paramPrefix
+      })
+    );
+
+    this.$('.js-promo-rule-option-value-product-select').productAutocomplete({multiple: false});
+
+    var productSelect = this.$el.find(".js-promo-rule-option-value-product-select")
+
+    this.$('.js-promo-rule-option-value-option-values-select').optionValueAutocomplete({ productSelect })
+
+    if(this.productId == null) {
+      this.$('.js-promo-rule-option-value-option-values-select').prop('disabled', true);
+    }
+  },
+
+  onSelectProduct: function(e) {
+    this.productId = this.$('input.js-promo-rule-option-value-product-select').val();
+    this.render();
+  },
+
+  onRemove: function(e) {
+    this.remove();
+  },
+});
+
+Spree.Views.Promotions.OptionValuesRule = Backbone.View.extend({
+  initialize: function() {
+    _.bindAll(this, 'addOptionValue')
+    this.$optionValues = this.$('.js-promo-rule-option-values');
+    this.paramPrefix = this.$('.param-prefix').data('param-prefix');
+
+    var originalOptionValues = this.$optionValues.data('original-option-values')
+    if ($.isEmptyObject(originalOptionValues)) {
+      this.addOptionValue(null, null);
+    } else {
+      $.each(originalOptionValues, this.addOptionValue);
+    }
+  },
+
+  events: {
+    'click .js-add-promo-rule-option-value': 'onAdd'
+  },
+
+  addOptionValue: function(product, values) {
+    var row = new Spree.Views.Promotions.OptionValuesRuleRow({
+      productId: product,
+      values: values,
+      paramPrefix: this.paramPrefix
+    });
+
+    this.$optionValues.append(row.el);
+
+    row.render();
+  },
+
+  onAdd: function(e) {
+    e.preventDefault();
+    this.addOptionValue(null, null);
+  },
+});

data/app/assets/javascripts/spree/backend/views/promotions.js

@@ -0,0 +1,3 @@
+//= require spree/backend/namespaces.js
+
+window.Spree.Views.Promotions = {}

data/app/assets/stylesheets/solidus_legacy_promotions/promotions/_edit.scss

@@ -0,0 +1,138 @@
+#general_fields, #expiry_fields {
+  border-bottom: none;
+  margin-bottom: 0;
+  padding-bottom: 0;
+}
+
+#rules_container, #actions_container {
+  position: relative;
+
+  fieldset {
+    position: static !important;
+  }
+}
+
+.promotion-block {
+  padding: 0 1.25rem 0.5rem;
+  background-color: lighten($color-border, 5);
+  border: 1px solid $color-border;
+  border-radius: 3px;
+  margin-bottom: 15px;
+  position: relative;
+
+  .row {
+    margin-bottom: 0;
+  }
+
+  // Fix the padding added by the .fa icon rule
+  .fa:before {
+    padding-right: 0;
+  }
+
+  .promo-rule-option-value {
+    position: relative;
+    padding-bottom: 10px;
+
+    .remove {
+      cursor: pointer;
+      position: absolute;
+      right: 0;
+      top: 10px;
+
+      &:hover {
+        color: $color-red;
+      }
+    }
+  }
+
+  .tier {
+    position: relative;
+    padding-bottom: 10px;
+
+    > .row {
+      margin-left: 10px;
+    }
+
+    .remove {
+      position: absolute;
+      cursor: pointer;
+      left: 0;
+      top: 10px;
+
+      &:hover {
+        color: $color-red;
+      }
+    }
+  }
+
+  .right-align {
+    text-align: right;
+  }
+
+  .calculator-fields {
+    padding-bottom: 10px;
+  }
+
+  .field {
+    &.alpha {
+      margin-left: -1px;
+      padding-left: 11px;
+    }
+
+    &.omega {
+      margin-right: -1px;
+      padding-right: 11px;
+    }
+  }
+
+  &.action-remove {
+    background-color: lighten($color-red, 50);
+    border-color: lighten($color-red, 45);
+    text-decoration: line-through;
+
+    .promotion-title, input[type="text"], input[type="number"],
+    .token-input-list {
+      border-color: lighten($color-red, 45);
+    }
+  }
+
+  .add-line-item {
+    #add_quantity {
+      width: 50px;
+      margin-top: 15px;
+    }
+    button.add {
+      min-width: 80px;
+      margin-top: 30px;
+
+      &:before {
+        padding-right: 5px;
+      }
+    }
+  }
+
+  a.delete {
+    position: absolute;
+    top: 1.25rem;
+    right: 1.25rem;
+    cursor: pointer;
+
+    &:hover {
+      color: theme-color("danger");
+    }
+  }
+}
+
+.promotion-title {
+  text-align: left;
+  font-size: 1rem;
+  border-bottom: 1px solid $color-border;
+  padding: 0.75rem 0;
+  margin-bottom: 0.75rem;
+
+  &.no-text {
+    border: none;
+    padding-bottom: 0;
+    margin-bottom: 0.25rem;
+  }
+}

data/app/assets/stylesheets/solidus_legacy_promotions/promotions.scss

@@ -0,0 +1,3 @@
+@import "spree/backend/themes/classic";
+
+@import "solidus_legacy_promotions/promotions/edit";

data/app/assets/stylesheets/spree/backend/sections/_adjustments.scss

@@ -0,0 +1,3 @@
+.adjustment-ineligible {
+  text-decoration: line-through;
+}

data/app/decorators/solidus_legacy_promotions/controllers/solidus_admin/solidus_admin_adjustments_controller_decorator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SolidusLegacyPromotions
+  module SolidusAdminAdjustmentsControllerDecorator
+    private
+
+    def load_adjustments
+      @adjustments = @order
+        .all_adjustments
+        .eligible
+        .order("adjustable_type ASC, created_at ASC")
+        .ransack(params[:q])
+        .result
+    end
+
+    if Object.const_defined?("SolidusAdmin::AdjustmentsController")
+      SolidusAdmin::AdjustmentsController.prepend self
+    end
+  end
+end

data/app/decorators/solidus_legacy_promotions/lib/spree_order_state_machine_decorator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_dependency "spree/core/state_machines/order"
+
+module SolidusLegacyPromotions
+  module SpreeOrderStateMachineDecorator
+    def define_state_machine!
+      super
+      state_machine do
+        if states[:delivery]
+          before_transition from: :delivery, do: :apply_shipping_promotions
+        end
+      end
+    end
+
+    Spree::Core::StateMachines::Order::ClassMethods.prepend self
+  end
+end

data/app/decorators/solidus_legacy_promotions/models/spree_adjustment_decorator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module SolidusLegacyPromotions
+  module SpreeAdjustmentDecorator
+    def self.prepended(base)
+      base.belongs_to :promotion_code, class_name: 'Spree::PromotionCode', optional: true
+      base.validates :promotion_code, presence: true, if: :require_promotion_code?
+
+      base.scope :eligible, -> { where(eligible: true) }
+    end
+
+    # Recalculate and persist the amount from this adjustment's source based on
+    # the adjustable ({Order}, {Shipment}, or {LineItem})
+    #
+    # If the adjustment has no source (such as when created manually from the
+    # admin) or is closed, this is a noop.
+    #
+    # @return [BigDecimal] New amount of this adjustment
+    def recalculate
+      if finalized? && !tax?
+        return amount
+      end
+
+      # If the adjustment has no source, do not attempt to re-calculate the
+      # amount.
+      # Some scenarios where this happens:
+      #   - Adjustments that are manually created via the admin backend
+      #   - PromotionAction adjustments where the PromotionAction was deleted
+      #     after the order was completed.
+      if source.present?
+        self.amount = source.compute_amount(adjustable)
+
+        if promotion?
+          self.eligible = calculate_eligibility
+        end
+
+        # Persist only if changed
+        # This is only not a save! to avoid the extra queries to load the order
+        # (for validations) and to touch the adjustment.
+        update_columns(eligible:, amount:, updated_at: Time.current) if changed?
+      end
+      amount
+    end
+    deprecate :recalculate, deprecator: Spree.deprecator
+
+    # Calculates based on attached promotion (if this is a promotion
+    # adjustment) whether this promotion is still eligible.
+    # @api private
+    # @return [true,false] Whether this adjustment is eligible
+    def calculate_eligibility
+      if !finalized? && source && promotion?
+        source.promotion.eligible?(adjustable, promotion_code:)
+      else
+        eligible?
+      end
+    end
+    deprecate :calculate_eligibility, deprecator: ::Spree.deprecator
+
+    def eligible
+      self[:eligible]
+    end
+    alias_method :eligible?, :eligible
+
+    private
+
+    def legacy_promotion?
+      source_type == "Spree::PromotionAction"
+    end
+
+    def require_promotion_code?
+      legacy_promotion? && !source.promotion.apply_automatically && source.promotion.codes.any?
+    end
+
+    Spree::Adjustment.prepend self
+  end
+end

data/app/decorators/solidus_legacy_promotions/models/spree_calculator_returns_default_refund_amount_decorator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidusLegacyPromotions
+  module SpreeCalculatorReturnsDefaultRefundAmountDecorator
+    private
+
+    def weighted_order_adjustment_amount(inventory_unit)
+      inventory_unit.order.adjustments.eligible.non_tax.sum(:amount) * percentage_of_order_total(inventory_unit)
+    end
+
+    Spree::Calculator::Returns::DefaultRefundAmount.prepend self
+  end
+end

data/app/decorators/solidus_legacy_promotions/models/spree_line_item_decorator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidusLegacyPromotions
+  module SpreeLineItemDecorator
+    def total_before_tax
+      amount + adjustments.select { |value| !value.tax? && value.eligible? }.sum(&:amount)
+    end
+
+    Spree::LineItem.prepend self
+  end
+end

data/app/decorators/solidus_legacy_promotions/models/spree_order_decorator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SolidusLegacyPromotions
+  module SpreeOrderDecorator
+    module ClassMethods
+      def allowed_ransackable_associations
+        super + ["promotions", "order_promotions"]
+      end
+    end
+
+    def self.prepended(base)
+      base.has_many :order_promotions, class_name: 'Spree::OrderPromotion', dependent: :destroy
+      base.has_many :promotions, through: :order_promotions
+    end
+
+    def apply_shipping_promotions(_event = nil)
+      Spree::Config.promotions.shipping_promotion_handler_class.new(self).activate
+      recalculate
+    end
+
+    def shipping_discount
+      shipment_adjustments.credit.eligible.sum(:amount) * - 1
+    end
+
+    Spree::Order.prepend(self)
+    Spree::Order.singleton_class.prepend self::ClassMethods
+  end
+end

data/app/decorators/solidus_legacy_promotions/models/spree_order_updater_decorator.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusLegacyPromotions
+  module SpreeOrderUpdaterDecorator
+    def update_adjustment_total
+      recalculate_adjustments
+
+      all_items = line_items + shipments
+      order_tax_adjustments = adjustments.select(&:eligible?).select(&:tax?)
+
+      order.adjustment_total = all_items.sum(&:adjustment_total) + adjustments.select(&:eligible?).sum(&:amount)
+      order.included_tax_total = all_items.sum(&:included_tax_total) + order_tax_adjustments.select(&:included?).sum(&:amount)
+      order.additional_tax_total = all_items.sum(&:additional_tax_total) + order_tax_adjustments.reject(&:included?).sum(&:amount)
+
+      update_order_total
+    end
+
+    def update_item_totals
+      [*line_items, *shipments].each do |item|
+        # The cancellation_total isn't persisted anywhere but is included in
+        # the adjustment_total
+        item.adjustment_total = item.adjustments.
+          select(&:eligible?).
+          reject(&:included?).
+          sum(&:amount)
+
+        if item.changed?
+          item.update_columns(
+            promo_total:          item.promo_total,
+            included_tax_total:   item.included_tax_total,
+            additional_tax_total: item.additional_tax_total,
+            adjustment_total:     item.adjustment_total,
+            updated_at:           Time.current,
+          )
+        end
+      end
+    end
+    Spree::OrderUpdater.prepend self
+  end
+end

data/app/decorators/solidus_legacy_promotions/models/spree_product_decorator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SolidusLegacyPromotions
+  module SpreeProductDecorator
+    def self.prepended(base)
+      base.has_many :product_promotion_rules, dependent: :destroy
+      base.has_many :promotion_rules, through: :product_promotion_rules
+
+      base.after_discard do
+        self.product_promotion_rules = []
+      end
+    end
+
+    ::Spree::Product.prepend self
+  end
+end

data/app/decorators/solidus_legacy_promotions/models/spree_promotion_code_batch_decorator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SolidusLegacyPromotions
+  module SpreePromotionCodeBatchDecorator
+    def process
+      if state == "pending"
+        update!(state: "processing")
+        Spree::PromotionCodeBatchJob.perform_later(self)
+      else
+        raise Spree::PromotionCodeBatch::CantProcessStartedBatch.new("Batch #{id} already started")
+      end
+    end
+
+    Spree::PromotionCodeBatch.prepend(self)
+  end
+end

data/app/decorators/solidus_legacy_promotions/models/spree_shipment_decorator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidusLegacyPromotions
+  module SpreeShipmentDecorator
+    # @return [BigDecimal] the amount of this item, taking into consideration
+    #   all non-tax eligible adjustments.
+    def total_before_tax
+      amount + adjustments.select { |adjustment| !adjustment.tax? && adjustment.eligible? }.sum(&:amount)
+    end
+
+    Spree::Shipment.prepend self
+  end
+end

data/app/helpers/spree/admin/promotions_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    module PromotionsHelper
+      def admin_promotion_status(promotion)
+        return :active if promotion.active?
+        return :not_started if promotion.not_started?
+        return :expired if promotion.expired?
+
+        :inactive
+      end
+    end
+  end
+end

data/app/helpers/spree/promotion_rules_helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Spree
+  module PromotionRulesHelper
+    def options_for_promotion_rule_types(promotion)
+      existing = promotion.rules.map { |rule| rule.class.name }
+      rules = Spree::Config.promotions.rules.reject { |rule| existing.include? rule.name }
+      options = rules.map { |rule| [rule.model_name.human, rule.name] }
+      options_for_select(options)
+    end
+  end
+end

data/app/jobs/spree/promotion_code_batch_job.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spree
+  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?
+        Spree::Config.promotions.promotion_code_batch_mailer_class
+          .promotion_code_batch_finished(promotion_code_batch)
+          .deliver_now
+      end
+    rescue StandardError => error
+      if promotion_code_batch.email?
+        Spree::Config.promotions.promotion_code_batch_mailer_class
+          .promotion_code_batch_errored(promotion_code_batch)
+          .deliver_now
+      end
+      raise error
+    end
+  end
+end

data/app/mailers/spree/promotion_code_batch_mailer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Spree
+  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/spree/calculator/distributed_amount.rb

@@ -0,0 +1,33 @@
+# 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 Spree
+  class Calculator::DistributedAmount < 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?
+      return 0 unless calculable.promotion.line_item_actionable?(line_item.order, line_item)
+      Spree::DistributedAmountsHandler.new(
+        actionable_line_items(line_item.order),
+        preferred_amount
+      ).amount(line_item)
+    end
+
+    private
+
+    def actionable_line_items(order)
+      order.line_items.select do |line_item|
+        calculable.promotion.line_item_actionable?(order, line_item)
+      end
+    end
+  end
+end

data/app/models/spree/calculator/flat_percent_item_total.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::FlatPercentItemTotal < Calculator
+    preference :flat_percent, :decimal, default: 0
+
+    def compute(object)
+      order = object.is_a?(Order) ? object : object.order
+      preferred_currency = order.currency
+      currency_exponent = ::Money::Currency.find(preferred_currency).exponent
+      computed_amount = (object.amount * preferred_flat_percent / 100).round(currency_exponent)
+
+      # We don't want to cause the promotion adjustments to push the order into a negative total.
+      if computed_amount > object.amount
+        object.amount
+      else
+        computed_amount
+      end
+    end
+  end
+end

data/app/models/spree/calculator/flexi_rate.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::FlexiRate < 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

data/app/models/spree/calculator/percent_on_line_item.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::PercentOnLineItem < Calculator
+    preference :percent, :decimal, default: 0
+
+    def compute(object)
+      (object.amount * preferred_percent) / 100
+    end
+  end
+end