solidus_friendly_promotions 1.0.0.pre

data/app/controllers/solidus_friendly_promotions/admin/base_controller.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Admin
+    class BaseController < Spree::Admin::ResourceController
+      def parent
+        @parent ||= self.class.parent_data[:model_class]
+          .includes(self.class.parent_data[:includes])
+          .find_by!(self.class.parent_data[:find_by] => params["#{parent_model_name}_id"])
+        instance_variable_set("@#{parent_model_name}", @parent)
+      rescue ActiveRecord::RecordNotFound => e
+        resource_not_found(flash_class: e.model.constantize, redirect_url: routes_proxy.polymorphic_url([:admin, parent_model_name.pluralize.to_sym]))
+      end
+
+      def new_object_url(options = {})
+        if parent?
+          routes_proxy.new_polymorphic_url([:admin, parent, model_class], options)
+        else
+          routes_proxy.new_polymorphic_url([:admin, model_class], options)
+        end
+      end
+
+      def edit_object_url(object, options = {})
+        if parent?
+          routes_proxy.polymorphic_url([:edit, :admin, parent, object], options)
+        else
+          routes_proxy.polymorphic_url([:edit, :admin, object], options)
+        end
+      end
+
+      def object_url(object = nil, options = {})
+        target = object || @object
+
+        if parent?
+          routes_proxy.polymorphic_url([:admin, parent, target], options)
+        else
+          routes_proxy.polymorphic_url([:admin, target], options)
+        end
+      end
+
+      def collection_url(options = {})
+        if parent?
+          routes_proxy.polymorphic_url([:admin, parent, model_class], options)
+        else
+          routes_proxy.polymorphic_url([:admin, model_class], options)
+        end
+      end
+
+      def routes_proxy
+        solidus_friendly_promotions
+      end
+    end
+  end
+end

data/app/controllers/solidus_friendly_promotions/admin/promotion_actions_controller.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Admin
+    class PromotionActionsController < Spree::Admin::BaseController
+      before_action :validate_level, only: :new
+      before_action :load_promotion, only: [:create, :destroy, :new, :update, :edit]
+      before_action :validate_promotion_action_type, only: [:create, :edit]
+
+      def new
+        if params.dig(:promotion_action, :type)
+          validate_promotion_action_type
+          @promotion_action = @promotion.actions.build(type: @promotion_action_type)
+
+          if params.dig(:promotion_action, :calculator_type)
+            @promotion_action.calculator_type = params[:promotion_action][:calculator_type]
+          end
+        end
+        render layout: false
+      end
+
+      def create
+        @promotion_action = @promotion_action_type.new(promotion_action_params)
+        @promotion_action.promotion = @promotion
+        if @promotion_action.save(validate: false)
+          flash[:success] =
+            t("spree.successfully_created", resource: SolidusFriendlyPromotions::PromotionAction.model_name.human)
+          redirect_to location_after_save, format: :html
+        else
+          render :new, layout: false
+        end
+      end
+
+      def edit
+        @promotion_action = @promotion.actions.find(params[:id])
+        if params.dig(:promotion_action, :calculator_type)
+          @promotion_action.calculator_type = params[:promotion_action][:calculator_type]
+        end
+        render layout: false
+      end
+
+      def update
+        @promotion_action = @promotion.actions.find(params[:id])
+        @promotion_action.assign_attributes(promotion_action_params)
+        if @promotion_action.save
+          flash[:success] =
+            t("spree.successfully_updated", resource: SolidusFriendlyPromotions::PromotionAction.model_name.human)
+          redirect_to location_after_save, format: :html
+        else
+          render :edit
+        end
+      end
+
+      def destroy
+        @promotion_action = @promotion.actions.find(params[:id])
+        if @promotion_action.discard
+          flash[:success] =
+            t("spree.successfully_removed", resource: SolidusFriendlyPromotions::PromotionAction.model_name.human)
+        end
+        redirect_to location_after_save, format: :html
+      end
+
+      private
+
+      def location_after_save
+        solidus_friendly_promotions.edit_admin_promotion_path(@promotion)
+      end
+
+      def load_promotion
+        @promotion = SolidusFriendlyPromotions::Promotion.find(params[:promotion_id])
+      end
+
+      def validate_level
+        requested_level = params[:level].to_s
+        if requested_level.in?(["line_item", "shipment"])
+          @level = requested_level
+        else
+          @level = "line_item"
+          flash.now[:error] = t(:invalid_promotion_rule_level, scope: :solidus_friendly_promotions)
+        end
+      end
+
+      def promotion_action_params
+        params[:promotion_action].try(:permit!) || {}
+      end
+
+      def validate_promotion_action_type
+        requested_type = params[:promotion_action].delete(:type)
+        promotion_action_types = SolidusFriendlyPromotions.config.actions
+        @promotion_action_type = promotion_action_types.detect do |klass|
+          klass.name == requested_type
+        end
+        return if @promotion_action_type
+
+        flash[:error] = t("solidus_friendly_promotions.invalid_promotion_action")
+        respond_to do |format|
+          format.html { redirect_to solidus_friendly_promotions.edit_admin_promotion_path(@promotion) }
+          format.js { render layout: false }
+        end
+      end
+    end
+  end
+end

data/app/controllers/solidus_friendly_promotions/admin/promotion_categories_controller.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Admin
+    class PromotionCategoriesController < BaseController
+      private
+
+      def model_class
+        SolidusFriendlyPromotions::PromotionCategory
+      end
+    end
+  end
+end

data/app/controllers/solidus_friendly_promotions/admin/promotion_code_batches_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Admin
+    class PromotionCodeBatchesController < BaseController
+      belongs_to "solidus_friendly_promotions/promotion"
+
+      create.after :build_promotion_code_batch
+
+      def download
+        require "csv"
+
+        @promotion_code_batch = SolidusFriendlyPromotions::PromotionCodeBatch.find(
+          params[:promotion_code_batch_id]
+        )
+
+        send_data(
+          render_to_string,
+          filename: "promotion-code-batch-list-#{@promotion_code_batch.id}.csv"
+        )
+      end
+
+      private
+
+      def build_promotion_code_batch
+        @promotion_code_batch.process
+      end
+    end
+  end
+end

data/app/controllers/solidus_friendly_promotions/admin/promotion_codes_controller.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module SolidusFriendlyPromotions
+  module Admin
+    class PromotionCodesController < BaseController
+      before_action :load_promotion
+
+      def index
+        @promotion_codes = @promotion.codes.order(:value)
+
+        respond_to do |format|
+          format.html do
+            @promotion_codes = @promotion_codes.page(params[:page]).per(50)
+          end
+          format.csv do
+            filename = "promotion-code-list-#{@promotion.id}.csv"
+            headers["Content-Type"] = "text/csv"
+            headers["Content-disposition"] = "attachment; filename=\"#{filename}\""
+          end
+        end
+      end
+
+      def new
+        if @promotion.apply_automatically
+          flash[:error] = t(
+            :disallowed_with_apply_automatically,
+            scope: "activerecord.errors.models.solidus_friendly_promotions/promotion_code.attributes.base"
+          )
+          redirect_to solidus_friendly_promotions.admin_promotion_promotion_codes_url(@promotion)
+        else
+          @promotion_code = @promotion.codes.build
+        end
+      end
+
+      def create
+        @promotion_code = @promotion.codes.build(value: params[:promotion_code][:value])
+
+        if @promotion_code.save
+          flash[:success] = flash_message_for(@promotion_code, :successfully_created)
+          redirect_to solidus_friendly_promotions.admin_promotion_promotion_codes_url(@promotion)
+        else
+          flash.now[:error] = @promotion_code.errors.full_messages.to_sentence
+          render_after_create_error
+        end
+      end
+
+      private
+
+      def load_promotion
+        @promotion = SolidusFriendlyPromotions::Promotion
+          .accessible_by(current_ability, :show)
+          .find(params[:promotion_id])
+      end
+    end
+  end
+end

data/app/controllers/solidus_friendly_promotions/admin/promotion_rules_controller.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Admin
+    class PromotionRulesController < Spree::Admin::BaseController
+      helper "spree/promotion_rules"
+
+      before_action :validate_level, only: [:new, :create]
+      before_action :load_promotion, only: [:create, :destroy, :update, :new]
+      before_action :validate_promotion_rule_type, only: [:create]
+
+      def new
+        if params.dig(:promotion_rule, :type)
+          validate_promotion_rule_type
+          @promotion_rule = @promotion.rules.build(type: @promotion_rule_type)
+        end
+        render layout: false
+      end
+
+      def create
+        @promotion_rule = @promotion.rules.build(
+          promotion_rule_params.merge(type: @promotion_rule_type.to_s)
+        )
+        if @promotion_rule.save
+          flash[:success] =
+            t("spree.successfully_created", resource: SolidusFriendlyPromotions::PromotionRule.model_name.human)
+        end
+        redirect_to location_after_save
+      end
+
+      def update
+        @promotion_rule = @promotion.rules.find(params[:id])
+        @promotion_rule.assign_attributes(promotion_rule_params)
+        if @promotion_rule.save
+          flash[:success] =
+            t("spree.successfully_updated", resource: SolidusFriendlyPromotions::PromotionRule.model_name.human)
+        end
+        redirect_to location_after_save
+      end
+
+      def destroy
+        @promotion_rule = @promotion.rules.find(params[:id])
+        if @promotion_rule.destroy
+          flash[:success] =
+            t("spree.successfully_removed", resource: SolidusFriendlyPromotions::PromotionRule.model_name.human)
+        end
+        redirect_to location_after_save
+      end
+
+      private
+
+      def location_after_save
+        solidus_friendly_promotions.edit_admin_promotion_path(@promotion)
+      end
+
+      def load_promotion
+        @promotion = SolidusFriendlyPromotions::Promotion.find(params[:promotion_id])
+      end
+
+      def model_class
+        SolidusFriendlyPromotions::PromotionRule
+      end
+
+      def validate_promotion_rule_type
+        requested_type = params[:promotion_rule].delete(:type)
+        promotion_rule_types = SolidusFriendlyPromotions.config.send("#{@level}_rules")
+        @promotion_rule_type = promotion_rule_types.detect do |klass|
+          klass.name == requested_type
+        end
+        return if @promotion_rule_type
+
+        flash[:error] = t("solidus_friendly_promotions.invalid_promotion_rule")
+        respond_to do |format|
+          format.html { redirect_to solidus_friendly_promotions.edit_admin_promotion_path(@promotion) }
+          format.js { render layout: false }
+        end
+      end
+
+      def validate_level
+        requested_level = params[:level].to_s
+        if requested_level.in?(["order", "line_item", "shipment"])
+          @level = requested_level
+        else
+          @level = "order"
+          flash.now[:error] = t(:invalid_promotion_rule_level, scope: :solidus_friendly_promotions)
+        end
+      end
+
+      def promotion_rule_params
+        params[:promotion_rule].try(:permit!) || {}
+      end
+
+      def promotion_rule_types
+        case params[:level]
+        when "order"
+          SolidusFriendlyPromotions.config.order_rules
+        when "line_item"
+          SolidusFriendlyPromotions.config.line_item_rules
+        when "shipment"
+          SolidusFriendlyPromotions.config.shipment_rules
+        end
+      end
+    end
+  end
+end

data/app/controllers/solidus_friendly_promotions/admin/promotions_controller.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Admin
+    class PromotionsController < BaseController
+      before_action :load_data
+
+      helper "solidus_friendly_promotions/admin/promotion_rules"
+      helper "solidus_friendly_promotions/admin/promotion_actions"
+
+      def create
+        @promotion = model_class.new(permitted_resource_params)
+        @promotion.codes.new(value: params[:single_code]) if params[:single_code].present?
+
+        if params[:code_batch]
+          @code_batch = @promotion.code_batches.new(code_batch_params)
+        end
+
+        if @promotion.save
+          @code_batch&.process
+          flash[:success] = t("solidus_friendly_promotions.promotion_successfully_created")
+          redirect_to location_after_save
+        else
+          flash[:error] = @promotion.errors.full_messages.to_sentence
+          render action: "new"
+        end
+      end
+
+      private
+
+      def collection
+        return @collection if @collection
+
+        params[:q] ||= HashWithIndifferentAccess.new
+        params[:q][:s] ||= "id desc"
+
+        @collection = super
+        @search = @collection.ransack(params[:q])
+        @collection = @search.result(distinct: true)
+          .includes(promotion_includes)
+          .page(params[:page])
+          .per(params[:per_page] || SolidusFriendlyPromotions.config.promotions_per_page)
+
+        @collection
+      end
+
+      def promotion_includes
+        [:actions]
+      end
+
+      def model_class
+        SolidusFriendlyPromotions::Promotion
+      end
+
+      def load_data
+        @promotion_categories = PromotionCategory.order(:name)
+      end
+
+      def location_after_save
+        solidus_friendly_promotions.edit_admin_promotion_url(@promotion)
+      end
+    end
+  end
+end

data/app/decorators/models/solidus_friendly_promotions/adjustment_decorator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module AdjustmentDecorator
+    def self.prepended(base)
+      base.scope :friendly_promotion, -> { where(source_type: "SolidusFriendlyPromotions::PromotionAction") }
+      base.scope :promotion, -> { where(source_type: ["SolidusFriendlyPromotions::PromotionAction", "Spree::PromotionAction"]) }
+    end
+
+    def friendly_promotion?
+      source_type == "SolidusFriendlyPromotions::PromotionAction"
+    end
+
+    def promotion?
+      super || source_type == "SolidusFriendlyPromotions::PromotionAction"
+    end
+
+    private
+
+    def require_promotion_code?
+      !friendly_promotion? && super
+    end
+
+    Spree::Adjustment.prepend self
+  end
+end

data/app/decorators/models/solidus_friendly_promotions/line_item_decorator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module LineItemDecorator
+    Spree::LineItem.prepend SolidusFriendlyPromotions::DiscountableAmount
+  end
+end

data/app/decorators/models/solidus_friendly_promotions/order_decorator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module OrderDecorator
+    def self.prepended(base)
+      base.has_many :friendly_order_promotions,
+        class_name: "SolidusFriendlyPromotions::OrderPromotion",
+        dependent: :destroy,
+        inverse_of: :order
+      base.has_many :friendly_promotions, through: :friendly_order_promotions, source: :promotion
+    end
+
+    def ensure_promotions_eligible
+      Spree::Config.promotion_adjuster_class.new(self).call
+      if promo_total_changed?
+        restart_checkout_flow
+        recalculate
+        errors.add(:base, I18n.t("solidus_friendly_promotions.promotion_total_changed_before_complete"))
+      end
+      errors.empty?
+    end
+
+    def discountable_item_total
+      line_items.sum(&:discountable_amount)
+    end
+
+    def reset_current_discounts
+      line_items.each(&:reset_current_discounts)
+      shipments.each(&:reset_current_discounts)
+    end
+
+    def apply_shipping_promotions
+      if Spree::Config.promotion_adjuster_class <= SolidusFriendlyPromotions::FriendlyPromotionAdjuster
+        recalculate
+      else
+        super
+      end
+    end
+
+    Spree::Order.prepend self
+  end
+end

data/app/decorators/models/solidus_friendly_promotions/order_recalculator_decorator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module OrderRecalculatorDecorator
+    def recalculate
+      if SolidusFriendlyPromotions.config.sync_order_promotions
+        MigrationSupport::OrderPromotionSyncer.new(order: order).call
+      end
+      super
+    end
+    Spree::Config.order_recalculator_class.prepend self
+  end
+end

data/app/decorators/models/solidus_friendly_promotions/shipment_decorator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module ShipmentDecorator
+    Spree::Shipment.prepend SolidusFriendlyPromotions::DiscountableAmount
+
+    def reset_current_discounts
+      super
+      shipping_rates.each(&:reset_current_discounts)
+    end
+
+    Spree::Shipment.prepend self
+  end
+end

data/app/decorators/models/solidus_friendly_promotions/shipping_rate_decorator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module ShippingRateDecorator
+    def self.prepended(base)
+      base.class_eval do
+        has_many :discounts,
+          class_name: "SolidusFriendlyPromotions::ShippingRateDiscount",
+          foreign_key: :shipping_rate_id,
+          dependent: :destroy,
+          inverse_of: :shipping_rate,
+          autosave: true
+
+        money_methods :total_before_tax, :promo_total
+      end
+    end
+
+    def total_before_tax
+      amount + promo_total
+    end
+
+    def promo_total
+      discounts.sum(&:amount)
+    end
+
+    Spree::ShippingRate.prepend SolidusFriendlyPromotions::DiscountableAmount
+    Spree::ShippingRate.prepend self
+  end
+end

data/app/helpers/solidus_friendly_promotions/admin/promotion_actions_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Admin
+    module PromotionActionsHelper
+      def options_for_promotion_action_calculator_types(promotion_action)
+        calculators = promotion_action.available_calculators
+        options = calculators.map { |calculator| [calculator.model_name.human, calculator.name] }
+        options_for_select(options, promotion_action.calculator_type.to_s)
+      end
+
+      def options_for_promotion_action_types(promotion_action)
+        actions = SolidusFriendlyPromotions.config.actions
+        options = actions.map { |action| [action.model_name.human, action.name] }
+        options_for_select(options, promotion_action&.type&.to_s)
+      end
+
+      def promotion_actions_by_level(promotion, level)
+        promotion.actions.select { |action| action.level == level }
+      end
+    end
+  end
+end

data/app/helpers/solidus_friendly_promotions/admin/promotion_rules_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Admin
+    module PromotionRulesHelper
+      def options_for_promotion_rule_types(promotion_rule, level)
+        existing = promotion_rule.promotion.rules.select(&:persisted?).map { |rule| rule.class.name }
+        rules = SolidusFriendlyPromotions.config.send("#{level}_rules").reject { |rule| existing.include? rule.name }
+        options = rules.map { |rule| [rule.model_name.human, rule.name] }
+        options_for_select(options, promotion_rule.type.to_s)
+      end
+
+      def promotion_rules_by_level(promotion, level)
+        promotion.rules.select do |rule|
+          rule.level == level || rule_applicable_by_preference(rule, level)
+        end
+      end
+
+      def rule_applicable_by_preference(rule, level)
+        method_name = "preferred_#{level}_applicable"
+        rule.respond_to?(method_name) && rule.send(method_name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+import { Application } from "@hotwired/stimulus";
+
+const application = Application.start();
+
+// Configure Stimulus development experience
+application.debug = false;
+window.Stimulus = application;
+
+export { application };

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

@@ -0,0 +1,37 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  static targets = ["links", "template"];
+
+  connect() {
+    this.wrapperClass = this.data.get("wrapperClass") || "calculator-tiers";
+  }
+
+  add_association(event) {
+    event.preventDefault();
+
+    var content = this.templateTarget.innerHTML;
+    this.linksTarget.insertAdjacentHTML("beforebegin", content);
+  }
+
+  propagate_base_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 valueInput = wrapper.querySelector(".js-value-input");
+    valueInput.name = valueInput.name.replace(
+      regEx,
+      `$1[${event.target.value}]`
+    );
+  }
+
+  remove_association(event) {
+    event.preventDefault();
+
+    let wrapper = event.target.closest("." + this.wrapperClass);
+    wrapper.remove();
+  }
+}

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

@@ -0,0 +1,10 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  connect() {
+    window.show_flash(
+      this.element.dataset.severity,
+      this.element.dataset.message
+    );
+  }
+}