solidus_promotions 4.4.0

data/lib/solidus_promotions/promotion_map.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  # This constants maps rules and actions from the legacy promotion system to conditions and benefits, respectively.
+  # This is used to migrate promotions from the legacy promotion system to the new one.
+  # If you have custom rules or actions, you can add them to this hash like so:
+
+  # # lib/my_store/promotion_map.rb
+  # require "solidus_promotions/promotion_map"
+  #
+  # MyStore::PROMOTION_MAP = SolidusPromotions::PROMOTION_MAP.merge(
+  #   conditions: {
+  #     Spree::Promotion::Rules::MyCustomRule => MyStore::Conditions::MyCustomCondition
+  #   },
+  #   actions: {
+  #     Spree::Promotion::Actions::MyCustomAction => MyStore::Benefits::MyCustomAction
+  #   }
+  # )
+
+  # And then use it in a custom rake task like so:
+
+  # # lib/rake/my_store.rake
+  # namespace :my_store do
+  #   desc "Migrate Spree Promotions to Friendly Promotions using a map"
+  #   task migrate_existing_promotions: :environment do
+  #     require "solidus_promotions/promotion_migrator"
+  #     require "my_store/promotion_map"
+  #     SolidusPromotions::PromotionMigrator.new(MyStore::PROMOTION_MAP).call
+  #   end
+  # end
+
+  # Note that the key in both the conditions and actions hash should be the class of the rule or action you want to map, while the value can be either
+  # a class or a lambda that returns a class. If you use a lambda, it will be called with the old action or rule as an argument.
+  PROMOTION_MAP = {
+    conditions: {
+      Spree::Promotion::Rules::ItemTotal =>
+        SolidusPromotions::Conditions::ItemTotal,
+      Spree::Promotion::Rules::Product =>
+        SolidusPromotions::Conditions::Product,
+      Spree::Promotion::Rules::User =>
+        SolidusPromotions::Conditions::User,
+      Spree::Promotion::Rules::FirstOrder =>
+        SolidusPromotions::Conditions::FirstOrder,
+      Spree::Promotion::Rules::UserLoggedIn =>
+        SolidusPromotions::Conditions::UserLoggedIn,
+      Spree::Promotion::Rules::OneUsePerUser =>
+        SolidusPromotions::Conditions::OneUsePerUser,
+      Spree::Promotion::Rules::Taxon =>
+        SolidusPromotions::Conditions::Taxon,
+      Spree::Promotion::Rules::NthOrder =>
+        SolidusPromotions::Conditions::NthOrder,
+      Spree::Promotion::Rules::OptionValue =>
+        SolidusPromotions::Conditions::OptionValue,
+      Spree::Promotion::Rules::FirstRepeatPurchaseSince =>
+        SolidusPromotions::Conditions::FirstRepeatPurchaseSince,
+      Spree::Promotion::Rules::UserRole =>
+        SolidusPromotions::Conditions::UserRole,
+      Spree::Promotion::Rules::Store =>
+        SolidusPromotions::Conditions::Store
+    },
+    actions: {
+      Spree::Promotion::Actions::CreateAdjustment => ->(old_action) {
+        calculator = case old_action.calculator
+                     when Spree::Calculator::FlatRate
+          SolidusPromotions::Calculators::DistributedAmount.new(preferences: old_action.calculator.preferences)
+                     when Spree::Calculator::FlatPercentItemTotal
+          SolidusPromotions::Calculators::Percent.new(preferred_percent: old_action.calculator.preferred_flat_percent)
+        end
+
+        SolidusPromotions::Benefits::AdjustLineItem.new(
+          calculator: calculator
+        )
+      },
+      Spree::Promotion::Actions::CreateItemAdjustments => ->(old_action) {
+        preferences = old_action.calculator.preferences
+        calculator = case old_action.calculator
+                     when Spree::Calculator::FlatRate
+          SolidusPromotions::Calculators::FlatRate.new(preferences: preferences)
+                     when Spree::Calculator::PercentOnLineItem
+          SolidusPromotions::Calculators::Percent.new(preferences: preferences)
+                     when Spree::Calculator::FlexiRate
+          SolidusPromotions::Calculators::FlexiRate.new(preferences: preferences)
+                     when Spree::Calculator::DistributedAmount
+          SolidusPromotions::Calculators::DistributedAmount.new(preferences: preferences)
+                     when Spree::Calculator::TieredFlatRate
+          SolidusPromotions::Calculators::TieredFlatRate.new(preferences: preferences)
+                     when Spree::Calculator::TieredPercent
+          SolidusPromotions::Calculators::TieredPercent.new(preferences: preferences)
+        end
+
+        SolidusPromotions::Benefits::AdjustLineItem.new(
+          calculator: calculator
+        )
+      },
+      Spree::Promotion::Actions::CreateQuantityAdjustments => ->(old_action) {
+        preferences = old_action.calculator.preferences
+        calculator = case old_action.calculator
+                     when Spree::Calculator::FlatRate
+          SolidusPromotions::Calculators::FlatRate.new(preferences: preferences)
+                     when Spree::Calculator::PercentOnLineItem
+          SolidusPromotions::Calculators::Percent.new(preferences: preferences)
+                     when Spree::Calculator::FlexiRate
+          SolidusPromotions::Calculators::FlexiRate.new(preferences: preferences)
+                     when Spree::Calculator::DistributedAmount
+          SolidusPromotions::Calculators::DistributedAmount.new(preferences: preferences)
+                     when Spree::Calculator::TieredFlatRate
+          SolidusPromotions::Calculators::TieredFlatRate.new(preferences: preferences)
+                     when Spree::Calculator::TieredPercent
+          SolidusPromotions::Calculators::TieredPercent.new(preferences: preferences)
+        end
+
+        SolidusPromotions::Benefits::AdjustLineItemQuantityGroups.new(
+          preferred_group_size: old_action.preferred_group_size,
+          calculator: calculator
+        )
+      },
+      Spree::Promotion::Actions::FreeShipping => ->(_old_action) {
+        SolidusPromotions::Benefits::AdjustShipment.new(
+          calculator: SolidusPromotions::Calculators::Percent.new(
+            preferred_percent: 100
+          )
+        )
+      }
+    }
+  }
+end

data/lib/solidus_promotions/promotion_migrator.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module SolidusPromotions
+  class PromotionMigrator
+    PROMOTION_IGNORED_ATTRIBUTES = ["id", "type", "promotion_category_id", "promotion_id"]
+
+    attr_reader :promotion_map
+
+    def initialize(promotion_map)
+      @promotion_map = promotion_map
+    end
+
+    def call
+      SolidusPromotions::PromotionCategory.destroy_all
+      Spree::PromotionCategory.all.find_each do |promotion_category|
+        SolidusPromotions::PromotionCategory.create!(promotion_category.attributes.except("id"))
+      end
+
+      SolidusPromotions::Promotion.destroy_all
+      Spree::Promotion.all.find_each do |promotion|
+        new_promotion = copy_promotion(promotion)
+        if promotion.promotion_category&.name.present?
+          new_promotion.category = SolidusPromotions::PromotionCategory.find_by(
+            name: promotion.promotion_category.name
+          )
+        end
+        new_promotion.benefits = promotion.actions.flat_map do |old_promotion_action|
+          generate_new_benefits(old_promotion_action)&.tap do |new_promotion_action|
+            new_promotion_action.original_promotion_action = old_promotion_action
+            new_promotion_action.conditions = promotion.rules.flat_map do |old_promotion_rule|
+              generate_new_promotion_conditions(old_promotion_rule)
+            end
+          end
+        end.compact
+        new_promotion.save!
+        copy_promotion_code_batches(new_promotion)
+        copy_promotion_codes(new_promotion)
+      end
+    end
+
+    private
+
+    def copy_promotion_code_batches(new_promotion)
+      sql = <<~SQL
+        INSERT INTO solidus_promotions_promotion_code_batches (promotion_id, base_code, number_of_codes, email, error, state, created_at, updated_at, join_characters)
+        SELECT solidus_promotions_promotions.id AS promotion_id, base_code, number_of_codes, email, error, state, spree_promotion_code_batches.created_at, spree_promotion_code_batches.updated_at, join_characters
+        FROM spree_promotion_code_batches
+        INNER JOIN spree_promotions ON spree_promotion_code_batches.promotion_id = spree_promotions.id
+        INNER JOIN solidus_promotions_promotions ON spree_promotions.id = solidus_promotions_promotions.original_promotion_id
+        WHERE spree_promotion_code_batches.promotion_id = #{new_promotion.original_promotion_id};
+      SQL
+      SolidusPromotions::PromotionCodeBatch.connection.execute(sql)
+    end
+
+    def copy_promotion_codes(new_promotion)
+      sql = <<~SQL
+        INSERT INTO solidus_promotions_promotion_codes (promotion_id, promotion_code_batch_id, value, created_at, updated_at)
+        SELECT solidus_promotions_promotions.id AS promotion_id, solidus_promotions_promotion_code_batches.id AS promotion_code_batch_id, value, spree_promotion_codes.created_at, spree_promotion_codes.updated_at
+        FROM spree_promotion_codes
+        LEFT OUTER JOIN spree_promotion_code_batches ON spree_promotion_code_batches.id = spree_promotion_codes.promotion_code_batch_id
+        LEFT OUTER JOIN solidus_promotions_promotion_code_batches ON solidus_promotions_promotion_code_batches.base_code = spree_promotion_code_batches.base_code
+        INNER JOIN spree_promotions ON spree_promotion_codes.promotion_id = spree_promotions.id
+        INNER JOIN solidus_promotions_promotions ON spree_promotions.id = solidus_promotions_promotions.original_promotion_id
+        WHERE spree_promotion_codes.promotion_id = #{new_promotion.original_promotion_id};
+      SQL
+      SolidusPromotions::PromotionCode.connection.execute(sql)
+    end
+
+    def copy_promotion(old_promotion)
+      SolidusPromotions::Promotion.new(
+        old_promotion.attributes.except(*PROMOTION_IGNORED_ATTRIBUTES).merge(
+          customer_label: old_promotion.name,
+          original_promotion: old_promotion
+        )
+      )
+    end
+
+    def generate_new_benefits(old_promotion_action)
+      promo_action_config = promotion_map[:actions][old_promotion_action.class]
+      if promo_action_config.nil?
+        puts("#{old_promotion_action.class} is not supported")
+        return nil
+      end
+      promo_action_config.call(old_promotion_action)
+    end
+
+    def generate_new_promotion_conditions(old_promotion_rule)
+      new_promo_condition_class = promotion_map[:conditions][old_promotion_rule.class]
+      if new_promo_condition_class.nil?
+        puts("#{old_promotion_rule.class} is not supported")
+        []
+      elsif new_promo_condition_class.respond_to?(:call)
+        new_promo_condition_class.call(old_promotion_rule)
+      else
+        new_condition = new_promo_condition_class.new(old_promotion_rule.attributes.except(*PROMOTION_IGNORED_ATTRIBUTES))
+        new_condition.preload_relations.each do |relation|
+          new_condition.send(:"#{relation}=", old_promotion_rule.send(relation))
+        end
+        [new_condition]
+      end
+    end
+  end
+end

data/lib/solidus_promotions/testing_support/factories/completed_order_with_solidus_promotion_factory.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :completed_order_with_solidus_promotion, parent: :order_with_line_items do
+    transient do
+      completed_at { Time.current }
+      promotion { nil }
+    end
+
+    after(:create) do |order, evaluator|
+      promotion = evaluator.promotion || create(:solidus_promotion, code: "test")
+      promotion_code = promotion.codes.first || create(:solidus_promotion_code, promotion: promotion)
+
+      order.solidus_order_promotions.create!(promotion: promotion, promotion_code: promotion_code)
+      order.recalculate
+      order.update_column(:completed_at, evaluator.completed_at)
+      order.update_column(:state, "complete")
+    end
+  end
+end

data/lib/solidus_promotions/testing_support/factories/solidus_order_promotion_factory.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :solidus_order_promotion, class: "SolidusPromotions::OrderPromotion" do
+    association :order, factory: :order
+    association :promotion, factory: :solidus_promotion
+  end
+end

data/lib/solidus_promotions/testing_support/factories/solidus_promotion_category_factory.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :solidus_promotion_category, class: "SolidusPromotions::PromotionCategory" do
+    name { "Promotion Category" }
+  end
+end

data/lib/solidus_promotions/testing_support/factories/solidus_promotion_code_factory.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :solidus_promotion_code, class: "SolidusPromotions::PromotionCode" do
+    association :promotion, factory: :solidus_promotion
+    sequence(:value) { |i| "code#{i}" }
+  end
+end

data/lib/solidus_promotions/testing_support/factories/solidus_promotion_factory.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :solidus_promotion, class: "SolidusPromotions::Promotion" do
+    name { "Promo" }
+    customer_label { "Because we like you" }
+
+    transient do
+      code { nil }
+    end
+    before(:create) do |promotion, evaluator|
+      if evaluator.code
+        promotion.codes << build(:solidus_promotion_code, promotion: promotion, value: evaluator.code)
+      end
+    end
+
+    trait :with_adjustable_benefit do
+      transient do
+        preferred_amount { 10 }
+        calculator_class { SolidusPromotions::Calculators::FlatRate }
+        promotion_benefit_class { SolidusPromotions::Benefits::AdjustLineItem }
+        conditions { [] }
+      end
+
+      after(:create) do |promotion, evaluator|
+        calculator = evaluator.calculator_class.new
+        calculator.preferred_amount = evaluator.preferred_amount
+        evaluator.promotion_benefit_class.create!(calculator: calculator, promotion: promotion, conditions: evaluator.conditions)
+      end
+    end
+
+    factory :solidus_promotion_with_benefit_adjustment, traits: [:with_adjustable_benefit]
+
+    trait :with_line_item_adjustment do
+      transient do
+        adjustment_rate { 10 }
+      end
+
+      with_adjustable_benefit
+      preferred_amount { adjustment_rate }
+    end
+
+    factory :solidus_promotion_with_item_adjustment, traits: [:with_line_item_adjustment]
+
+    trait :with_free_shipping do
+      after(:create) do |promotion|
+        calculator = SolidusPromotions::Calculators::Percent.new(preferred_percent: 100)
+
+        SolidusPromotions::Benefits::AdjustShipment.create!(promotion: promotion, calculator: calculator)
+      end
+    end
+
+    trait :with_order_adjustment do
+      transient do
+        weighted_order_adjustment_amount { 10 }
+      end
+
+      with_adjustable_benefit
+      preferred_amount { weighted_order_adjustment_amount }
+      calculator_class { SolidusPromotions::Calculators::DistributedAmount }
+    end
+
+    factory :solidus_promotion_with_order_adjustment, traits: [:with_order_adjustment]
+  end
+end

data/lib/solidus_promotions/testing_support/factories/solidus_shipping_rate_discount_factory.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :solidus_shipping_rate_discount, class: "SolidusPromotions::ShippingRateDiscount" do
+    amount { BigDecimal("-4.00") }
+    shipping_rate
+    benefit do
+      promotion = create(:solidus_promotion, name: "10% off shipping!", customer_label: "10% off")
+      ten_percent = SolidusPromotions::Calculators::Percent.new(preferred_percent: 10)
+      SolidusPromotions::Benefits::AdjustShipment.create!(promotion: promotion, calculator: ten_percent)
+    end
+    label { "10% off" }
+  end
+end

data/lib/solidus_promotions/testing_support/factory_bot.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "factory_bot"
+begin
+  require "factory_bot_rails"
+rescue LoadError
+end
+
+module SolidusPromotions
+  module TestingSupport
+    module FactoryBot
+      SEQUENCES = ["#{::SolidusPromotions::Engine.root}/lib/solidus_promotions/testing_support/sequences.rb"]
+      FACTORIES = Dir["#{::SolidusPromotions::Engine.root}/lib/solidus_promotions/testing_support/factories/**/*_factory.rb"].sort
+      PATHS = SEQUENCES + FACTORIES
+
+      def self.definition_file_paths
+        @paths ||= PATHS.map { |path| path.sub(/.rb\z/, "") }
+      end
+
+      def self.add_definitions!
+        ::FactoryBot.definition_file_paths.unshift(*definition_file_paths).uniq!
+      end
+
+      def self.add_paths_and_load!
+        add_definitions!
+        ::FactoryBot.reload
+      end
+    end
+  end
+end

data/lib/solidus_promotions.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "solidus_core"
+require "solidus_support"
+require "turbo-rails"
+require "importmap-rails"
+require "stimulus-rails"
+require "ransack-enum"
+
+# We carry controllers and views for both the traditional backend
+# and the new Solidus Admin interface, but we want to continue to function
+# if either of them are not present. If they are present,
+# however, they need to load before us.
+begin
+  require "solidus_backend"
+rescue LoadError
+  # Solidus backend is not available
+end
+
+begin
+  require "solidus_admin"
+rescue LoadError
+  # Solidus Admin is not available
+end
+
+module SolidusPromotions
+  def self.table_name_prefix
+    "solidus_promotions_"
+  end
+
+  # JS Importmap instance
+  singleton_class.attr_accessor :importmap
+  self.importmap = Importmap::Map.new
+end
+
+require "solidus_promotions/configuration"
+require "solidus_promotions/engine"

data/lib/tasks/solidus_promotions/migrate_adjustments.rake

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+namespace :solidus_promotions do
+  namespace :migrate_adjustments do
+    desc "Migrate adjustments with Spree::Benefit sources to SolidusPromotions::Benefit sources"
+    task up: :environment do
+      require "solidus_promotions/migrate_adjustments"
+      SolidusPromotions::MigrateAdjustments.up
+    end
+
+    desc "Migrate adjustments with SolidusPromotions::Benefit sources to Spree::Benefit sources"
+    task down: :environment do
+      require "solidus_promotions/migrate_adjustments"
+      SolidusPromotions::MigrateAdjustments.down
+    end
+  end
+end

data/lib/tasks/solidus_promotions/migrate_existing_promotions.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "solidus_promotions/promotion_migrator"
+
+namespace :solidus_promotions do
+  desc "Migrate Spree Promotions to Friendly Promotions using a map"
+  task migrate_existing_promotions: :environment do
+    require "solidus_promotions/promotion_map"
+
+    SolidusPromotions::PromotionMigrator.new(SolidusPromotions::PROMOTION_MAP).call
+  end
+end

data/lib/tasks/solidus_promotions/migrate_order_promotions.rake

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+namespace :solidus_promotions do
+  namespace :migrate_order_promotions do
+    desc "Migrate order promotions from Spree::OrderPromotion sources to SolidusPromotions::FriendlyOrderPromotion sources"
+    task up: :environment do
+      require "solidus_promotions/migrate_order_promotions"
+      SolidusPromotions::MigrateOrderPromotions.up
+    end
+
+    desc "Migrate order promotions from SolidusPromotions::FriendlyOrderPromotion sources to Spree::OrderPromotion sources"
+    task down: :environment do
+      require "solidus_promotions/migrate_order_promotions"
+      SolidusPromotions::MigrateOrderPromotions.down
+    end
+  end
+end

data/lib/views/backend/solidus_promotions/admin/benefit_fields/_adjust_line_item.html.erb

@@ -0,0 +1,6 @@
+<%= render(
+  "solidus_promotions/admin/benefit_fields/calculator_fields",
+  benefit: benefit,
+  param_prefix: param_prefix,
+  form: form
+) %>

data/lib/views/backend/solidus_promotions/admin/benefit_fields/_adjust_line_item_quantity_groups.html.erb

@@ -0,0 +1,13 @@
+<%= fields_for param_prefix, benefit do |form| %>
+  <div class="form-group">
+    <%= form.label :preferred_group_size %>
+    <%= form.number_field :preferred_group_size, class: "fullwidth", min: 1 %>
+  </div>
+<% end %>
+
+<%= render(
+  "solidus_promotions/admin/benefit_fields/calculator_fields",
+  benefit: benefit,
+  param_prefix: param_prefix,
+  form: form
+) %>

data/lib/views/backend/solidus_promotions/admin/benefit_fields/_adjust_shipment.html.erb

@@ -0,0 +1,6 @@
+<%= render(
+  "solidus_promotions/admin/benefit_fields/calculator_fields",
+  benefit: benefit,
+  param_prefix: param_prefix,
+  form: form
+) %>

data/lib/views/backend/solidus_promotions/admin/benefit_fields/_calculator_fields.erb

@@ -0,0 +1,11 @@
+
+<% calculator = benefit.calculator %>
+<% type_name = calculator.type.demodulize.underscore %>
+<p>
+  <%= calculator.description %>
+</p>
+<% if lookup_context.exists?("fields",  ["solidus_promotions/admin/calculator_fields/#{type_name}"], true) %>
+  <%= render "solidus_promotions/admin/calculator_fields/#{type_name}/fields", calculator: calculator, prefix: param_prefix, form: form %>
+<% else %>
+  <%= render "solidus_promotions/admin/calculator_fields/default_fields", calculator: calculator, prefix: param_prefix, form: form %>
+<% end %>

data/lib/views/backend/solidus_promotions/admin/benefit_fields/_create_discounted_item.html.erb

@@ -0,0 +1,21 @@
+<%= fields_for param_prefix, benefit do |form| %>
+  <div class="form-group">
+    <%= form.label :preferred_variant_id %>
+    <%= form.text_field :preferred_variant_id, is: "variant-picker", class: "fullwidth" %>
+  </div>
+  <div class="form-group">
+    <%= form.label :preferred_quantity %>
+    <%= form.number_field :preferred_quantity, class: "fullwidth" %>
+  </div>
+  <div class="form-group">
+    <%= form.label :preferred_necessary_quantity %>
+    <%= form.number_field :preferred_necessary_quantity, class: "fullwidth" %>
+  </div>
+<% end %>
+
+<%= render(
+  "solidus_promotions/admin/benefit_fields/calculator_fields",
+  benefit: benefit,
+  param_prefix: param_prefix,
+  form: form
+) %>

data/lib/views/backend/solidus_promotions/admin/benefits/_benefit.html.erb

@@ -0,0 +1,50 @@
+<div class="card bg-light primary mb-3">
+  <div id="<%= dom_id(benefit) %>_header" class="card-header">
+    <%= benefit.model_name.human %>
+
+    <span class="float-right text-dark">
+      <% if can?(:destroy, benefit) %>
+        <%= link_to_with_icon 'trash', '', solidus_promotions.admin_promotion_benefit_path(@promotion, benefit), method: :delete, class: 'delete' %>
+      <% end %>
+    </span>
+  </div>
+  <div class="card-body">
+    <div class="row">
+      <div class="col-md-6">
+        <%= turbo_frame_tag @promotion, dom_id(benefit) do %>
+
+          <%= render "solidus_promotions/admin/benefits/calculator_select",
+            path: solidus_promotions.edit_admin_promotion_benefit_path(@promotion, benefit),
+            benefit: benefit %>
+
+          <%=
+            form_with(
+            model: benefit,
+            scope: :benefit,
+            url: solidus_promotions.admin_promotion_benefit_path(@promotion, benefit),
+            data: { turbo: false }
+          ) do |form| %>
+            <%= render 'solidus_promotions/admin/benefits/form', form: form %>
+            <div class="row">
+              <div class="col-12">
+                <%= button_tag t(:update, scope: [:solidus_promotions, :crud]), class: "btn btn-secondary float-right" %>
+              </div>
+            </div>
+          <% end %>
+        <% end %>
+      </div>
+      <div class="col-md-6">
+        <div class="form-group">
+          <%= label_tag :conditions %>
+          <div id="<%= dom_id(benefit) %>_conditions" class="bg-white rounded border p-3">
+            <%= render partial: 'solidus_promotions/admin/conditions/condition', collection: benefit.conditions %>
+
+            <%= turbo_frame_tag benefit, "new_condition" do %>
+              <%= link_to t(:add_condition, scope: :solidus_promotions), solidus_promotions.new_admin_promotion_benefit_condition_path(@promotion, benefit), class: 'btn btn-secondary' %>
+            <% end %>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</div>

data/lib/views/backend/solidus_promotions/admin/benefits/_calculator_select.html.erb

@@ -0,0 +1,16 @@
+<%= form_with model: benefit, scope: :benefit, url: path, method: :get do |form| %>
+  <%= form.hidden_field :type %>
+  <div class="form-group">
+    <%= form.label :calculator_type %>
+    <%=
+      form.select :calculator_type,
+        options_for_benefit_calculator_types(form.object),
+        {
+          include_blank: t(:choose_benefit_calculator, scope: 'solidus_promotions')
+        },
+        class: 'custom-select fullwidth',
+        onchange: 'this.form.requestSubmit()',
+        required: true
+    %>
+  </div>
+<% end %>

data/lib/views/backend/solidus_promotions/admin/benefits/_form.html.erb

@@ -0,0 +1,3 @@
+<%= form.hidden_field :type %>
+<%= form.hidden_field :calculator_type %>
+<%= render form.object, benefit: form.object, param_prefix: form.object_name, form: form %>

data/lib/views/backend/solidus_promotions/admin/benefits/_new_benefit.html.erb

@@ -0,0 +1,33 @@
+<%= turbo_frame_tag benefit.promotion, "new_benefit" do %>
+<div class="card bg-light mb-3">
+  <div class="card-header">
+    <%= t(:add_benefit, scope: :solidus_promotions) %>
+  </div>
+  <div class="card-body">
+    <div class="row">
+      <div class="col-6">
+        <%= render 'solidus_promotions/admin/benefits/type_select', benefit: benefit %>
+        <% if benefit.available_calculators.any? %>
+          <%= render 'solidus_promotions/admin/benefits/calculator_select', path: solidus_promotions.new_admin_promotion_benefit_path(@promotion), benefit: benefit %>
+          <% if benefit.calculator %>
+            <%=
+              form_with(
+                model: benefit,
+                scope: :benefit,
+                url: solidus_promotions.admin_promotion_benefits_path(@promotion),
+                data: { turbo: false }
+              ) do |form| %>
+              <%= render 'form', form: form %>
+              <div class="row">
+                <div class="col-12">
+                  <%= button_tag t(:add, scope: [:solidus_promotions, :crud]), class: "btn btn-secondary float-right" %>
+                </div>
+              </div>
+            <% end %>
+          <% end %>
+        <% end %>
+      </div>
+    </div>
+  </div>
+</div>
+<% end %>