solidus_friendly_promotions 1.0.1 → 1.9.0

data/app/models/solidus_friendly_promotions/{rules → conditions}/store.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    class Store < PromotionRule
-      include OrderLevelRule
+  module Conditions
+    class Store < Condition
+      include OrderLevelCondition
 
-      has_many :promotion_rules_stores, class_name: "SolidusFriendlyPromotions::PromotionRulesStore",
-        foreign_key: :promotion_rule_id,
+      has_many :condition_stores, class_name: "SolidusFriendlyPromotions::ConditionStore",
+        foreign_key: :condition_id,
         dependent: :destroy
-      has_many :stores, through: :promotion_rules_stores, class_name: "Spree::Store"
+      has_many :stores, through: :condition_stores, class_name: "Spree::Store"
 
       def preload_relations
         [:stores]

data/app/models/solidus_friendly_promotions/{rules → conditions}/taxon.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    class Taxon < PromotionRule
-      include LineItemApplicableOrderRule
+  module Conditions
+    class Taxon < Condition
+      include LineItemApplicableOrderCondition
 
-      has_many :promotion_rules_taxons, class_name: "SolidusFriendlyPromotions::PromotionRulesTaxon", foreign_key: :promotion_rule_id,
+      has_many :condition_taxons, class_name: "SolidusFriendlyPromotions::ConditionTaxon", foreign_key: :condition_id,
         dependent: :destroy
-      has_many :taxons, through: :promotion_rules_taxons, class_name: "Spree::Taxon"
+      has_many :taxons, through: :condition_taxons, class_name: "Spree::Taxon"
 
       def preload_relations
         [:taxons]
@@ -24,15 +24,15 @@ module SolidusFriendlyPromotions
 
         case preferred_match_policy
         when "all"
-          matches_all = taxons.all? do |rule_taxon|
-            order_taxons.where(id: rule_taxon.self_and_descendants.ids).exists?
+          matches_all = taxons.all? do |condition_taxon|
+            order_taxons.where(id: condition_taxon.self_and_descendants.ids).exists?
           end
 
           unless matches_all
             eligibility_errors.add(:base, eligibility_error_message(:missing_taxon), error_code: :missing_taxon)
           end
         when "any"
-          unless order_taxons.where(id: rule_taxon_ids_with_children).exists?
+          unless order_taxons.where(id: condition_taxon_ids_with_children).exists?
             eligibility_errors.add(
               :base,
               eligibility_error_message(:no_matching_taxons),
@@ -40,7 +40,7 @@ module SolidusFriendlyPromotions
             )
           end
         when "none"
-          if order_taxons.where(id: rule_taxon_ids_with_children).exists?
+          if order_taxons.where(id: condition_taxon_ids_with_children).exists?
             eligibility_errors.add(
               :base,
               eligibility_error_message(:has_excluded_taxon),
@@ -63,7 +63,7 @@ module SolidusFriendlyPromotions
 
         Spree::Classification.where(
           product_id: line_item.variant.product_id,
-          taxon_id: rule_taxon_ids_with_children
+          taxon_id: condition_taxon_ids_with_children
         ).exists?
       end
 
@@ -89,8 +89,8 @@ module SolidusFriendlyPromotions
           .distinct
       end
 
-      # ids of taxons rules and taxons rules children
-      def rule_taxon_ids_with_children
+      # ids of taxons conditions and taxons conditions children
+      def condition_taxon_ids_with_children
         taxons.flat_map { |taxon| taxon.self_and_descendants.ids }.uniq
       end
     end

data/app/models/solidus_friendly_promotions/{rules → conditions}/user.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    class User < PromotionRule
-      include OrderLevelRule
+  module Conditions
+    class User < Condition
+      include OrderLevelCondition
 
-      has_many :promotion_rules_users,
-        class_name: "SolidusFriendlyPromotions::PromotionRulesUser",
-        foreign_key: :promotion_rule_id,
+      has_many :condition_users,
+        class_name: "SolidusFriendlyPromotions::ConditionUser",
+        foreign_key: :condition_id,
         dependent: :destroy
-      has_many :users, through: :promotion_rules_users, class_name: Spree::UserClassHandle.new
+      has_many :users, through: :condition_users, class_name: Spree::UserClassHandle.new
 
       def preload_relations
         [:users]

data/app/models/solidus_friendly_promotions/{rules → conditions}/user_logged_in.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    class UserLoggedIn < PromotionRule
-      include OrderLevelRule
+  module Conditions
+    class UserLoggedIn < Condition
+      include OrderLevelCondition
 
       def eligible?(order, _options = {})
         if order.user.blank?

data/app/models/solidus_friendly_promotions/{rules → conditions}/user_role.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  module Rules
-    class UserRole < PromotionRule
-      include OrderLevelRule
+  module Conditions
+    class UserRole < Condition
+      include OrderLevelCondition
 
       preference :role_ids, :array, default: []
 

data/app/models/solidus_friendly_promotions/eligibility_result.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidusFriendlyPromotions
-  EligibilityResult = Struct.new(:item, :rule, :success, :code, :message, keyword_init: true)
+  EligibilityResult = Struct.new(:item, :condition, :success, :code, :message, keyword_init: true)
 end

data/app/models/solidus_friendly_promotions/eligibility_results.rb

@@ -9,10 +9,10 @@ module SolidusFriendlyPromotions
       @results = []
     end
 
-    def add(item:, rule:, success:, code:, message:)
+    def add(item:, condition:, success:, code:, message:)
       results << EligibilityResult.new(
         item: item,
-        rule: rule,
+        condition: condition,
         success: success,
         code: code,
         message: message
@@ -21,17 +21,17 @@ module SolidusFriendlyPromotions
 
     def success?
       return true if results.empty?
-      promotion.actions.any? do |action|
-        action.relevant_rules.all? do |rule|
-          results_for_rule = results.select { |result| result.rule == rule }
-          results_for_rule.any?(&:success)
+      promotion.benefits.any? do |benefit|
+        benefit.conditions.all? do |condition|
+          results_for_condition = results.select { |result| result.condition == condition }
+          results_for_condition.any?(&:success)
         end
       end
     end
 
     def error_messages
       return [] if results.empty?
-      results.group_by(&:rule).map do |rule, results|
+      results.group_by(&:condition).map do |condition, results|
         next if results.any?(&:success)
         results.detect { |r| !r.success }&.message
       end.compact

data/app/models/solidus_friendly_promotions/friendly_promotion_adjuster/discount_order.rb

@@ -15,11 +15,12 @@ module SolidusFriendlyPromotions
         return order if order.shipped?
 
         SolidusFriendlyPromotions::Promotion.ordered_lanes.each do |lane, _index|
-          lane_promotions = eligible_promotions_for_promotable(promotions.select { |promotion| promotion.lane == lane }, order)
-          perform_order_actions(lane_promotions, lane) unless dry_run
-          line_item_discounts = adjust_line_items(lane_promotions)
-          shipment_discounts = adjust_shipments(lane_promotions)
-          shipping_rate_discounts = adjust_shipping_rates(lane_promotions)
+          lane_promotions = promotions.select { |promotion| promotion.lane == lane }
+          lane_benefits = eligible_benefits_for_promotable(lane_promotions.flat_map(&:benefits), order)
+          perform_order_benefits(lane_benefits, lane) unless dry_run
+          line_item_discounts = adjust_line_items(lane_benefits)
+          shipment_discounts = adjust_shipments(lane_benefits)
+          shipping_rate_discounts = adjust_shipping_rates(lane_benefits)
           (line_item_discounts + shipment_discounts + shipping_rate_discounts).each do |item, chosen_discounts|
             item.current_discounts.concat(chosen_discounts)
           end
@@ -30,64 +31,62 @@ module SolidusFriendlyPromotions
 
       private
 
-      def perform_order_actions(lane_promotions, lane)
-        lane_promotions.each do |promotion|
-          promotion.actions.select { |action| action.level == :order }.each { |action| action.perform(order) }
+      def perform_order_benefits(lane_benefits, lane)
+        lane_benefits.select { |benefit| benefit.level == :order }.each do |benefit|
+          benefit.perform(order)
         end
 
-        automated_line_items = order.line_items.select(&:managed_by_order_action)
+        automated_line_items = order.line_items.select(&:managed_by_order_benefit)
         return if automated_line_items.empty?
 
         ineligible_line_items = automated_line_items.select do |line_item|
-          line_item.managed_by_order_action.promotion.lane == lane && !line_item.managed_by_order_action.in?(lane_promotions.flat_map(&:actions))
+          line_item.managed_by_order_benefit.promotion.lane == lane && !line_item.managed_by_order_benefit.in?(lane_benefits)
         end
 
         ineligible_line_items.each do |line_item|
-          line_item.managed_by_order_action.remove_from(order)
+          line_item.managed_by_order_benefit.remove_from(order)
         end
       end
 
-      def adjust_line_items(promotions)
+      def adjust_line_items(benefits)
         order.discountable_line_items.select do |line_item|
           line_item.variant.product.promotionable?
         end.map do |line_item|
-          discounts = generate_discounts(promotions, line_item)
+          discounts = generate_discounts(benefits, line_item)
           chosen_item_discounts = SolidusFriendlyPromotions.config.discount_chooser_class.new(discounts).call
           [line_item, chosen_item_discounts]
         end
       end
 
-      def adjust_shipments(promotions)
+      def adjust_shipments(benefits)
         order.shipments.map do |shipment|
-          discounts = generate_discounts(promotions, shipment)
+          discounts = generate_discounts(benefits, shipment)
           chosen_item_discounts = SolidusFriendlyPromotions.config.discount_chooser_class.new(discounts).call
           [shipment, chosen_item_discounts]
         end
       end
 
-      def adjust_shipping_rates(promotions)
+      def adjust_shipping_rates(benefits)
         order.shipments.flat_map(&:shipping_rates).select(&:cost).map do |rate|
-          discounts = generate_discounts(promotions, rate)
+          discounts = generate_discounts(benefits, rate)
           chosen_item_discounts = SolidusFriendlyPromotions.config.discount_chooser_class.new(discounts).call
           [rate, chosen_item_discounts]
         end
       end
 
-      def eligible_promotions_for_promotable(possible_promotions, promotable)
-        possible_promotions.select do |candidate|
-          candidate.eligible_by_applicable_rules?(promotable, dry_run: dry_run)
+      def eligible_benefits_for_promotable(possible_benefits, promotable)
+        possible_benefits.select do |candidate|
+          candidate.eligible_by_applicable_conditions?(promotable, dry_run: dry_run)
         end
       end
 
-      def generate_discounts(possible_promotions, item)
-        eligible_promotions = eligible_promotions_for_promotable(possible_promotions, item)
-        eligible_promotions.flat_map do |promotion|
-          promotion.actions.select do |action|
-            action.can_discount?(item)
-          end.map do |action|
-            action.discount(item)
-          end.compact
-        end
+      def generate_discounts(possible_benefits, item)
+        eligible_benefits = eligible_benefits_for_promotable(possible_benefits, item)
+        eligible_benefits.select do |benefit|
+          benefit.can_discount?(item)
+        end.map do |benefit|
+          benefit.discount(item)
+        end.compact
       end
     end
   end

data/app/models/solidus_friendly_promotions/friendly_promotion_adjuster/load_promotions.rb

@@ -11,11 +11,11 @@ module SolidusFriendlyPromotions
       def call
         promos = connected_order_promotions | sale_promotions
         promos << dry_run_promotion if dry_run_promotion
-        promos.flat_map(&:actions).group_by(&:preload_relations).each do |preload_relations, actions|
-          preload(records: actions, associations: preload_relations)
-        end
-        promos.flat_map(&:rules).group_by(&:preload_relations).each do |preload_relations, rules|
-          preload(records: rules, associations: preload_relations)
+        promos.flat_map(&:benefits).group_by(&:preload_relations).each do |preload_relations, benefits|
+          preload(records: benefits, associations: preload_relations)
+          benefits.flat_map(&:conditions).group_by(&:preload_relations).each do |preload_relations, conditions|
+            preload(records: conditions, associations: preload_relations)
+          end
         end
         promos.reject { |promotion| promotion.usage_limit_exceeded?(excluded_orders: [order]) }
       end
@@ -30,13 +30,13 @@ module SolidusFriendlyPromotions
 
       def connected_order_promotions
         eligible_connected_promotion_ids = order.friendly_order_promotions.select do |order_promotion|
-          order_promotion.promotion_code.nil? || !order_promotion.promotion_code.usage_limit_exceeded?(excluded_orders: [order])
+          order_promotion.promotion.kept? && (order_promotion.promotion_code.nil? || !order_promotion.promotion_code.usage_limit_exceeded?(excluded_orders: [order]))
         end.map(&:promotion_id)
         order.friendly_promotions.active(reference_time).where(id: eligible_connected_promotion_ids).includes(promotion_includes)
       end
 
       def sale_promotions
-        SolidusFriendlyPromotions::Promotion.where(apply_automatically: true).active(reference_time).includes(promotion_includes)
+        SolidusFriendlyPromotions::Promotion.kept.where(apply_automatically: true).active(reference_time).includes(promotion_includes)
       end
 
       def reference_time
@@ -44,10 +44,9 @@ module SolidusFriendlyPromotions
       end
 
       def promotion_includes
-        [
-          :rules,
-          :actions
-        ]
+        {
+          benefits: :conditions
+        }
       end
     end
   end

data/app/models/solidus_friendly_promotions/friendly_promotion_adjuster/persist_discounted_order.rb

@@ -22,7 +22,7 @@ module SolidusFriendlyPromotions
               shipping_rate: shipping_rate,
               amount: discount.amount,
               label: discount.label,
-              promotion_action: discount.source
+              benefit: discount.source
             )
           end
         end
@@ -49,7 +49,7 @@ module SolidusFriendlyPromotions
           update_adjustment(item, item_discount)
         end
         item.update(promo_total: active_adjustments.sum(&:amount))
-        # Remove any tax adjustments tied to promotion actions which no longer match.
+        # Remove any tax adjustments tied to promotion benefits which no longer match.
         unmatched_adjustments = promotion_adjustments - active_adjustments
 
         item.adjustments.destroy(unmatched_adjustments)

data/app/models/solidus_friendly_promotions/order_promotion.rb

@@ -7,7 +7,7 @@ module SolidusFriendlyPromotions
   # 2. The specific code that they used
   class OrderPromotion < Spree::Base
     belongs_to :order, class_name: "Spree::Order"
-    belongs_to :promotion, class_name: "SolidusFriendlyPromotions::Promotion"
+    belongs_to :promotion, -> { with_discarded }, class_name: "SolidusFriendlyPromotions::Promotion"
     belongs_to :promotion_code, class_name: "SolidusFriendlyPromotions::PromotionCode", optional: true
 
     validates :promotion_code, presence: true, if: :require_promotion_code?

data/app/models/solidus_friendly_promotions/permission_sets/friendly_promotion_management.rb

@@ -6,7 +6,7 @@ module SolidusFriendlyPromotions
       def activate!
         can :manage, SolidusFriendlyPromotions::Promotion
         can :manage, SolidusFriendlyPromotions::PromotionRule
-        can :manage, SolidusFriendlyPromotions::PromotionAction
+        can :manage, SolidusFriendlyPromotions::Benefit
         can :manage, SolidusFriendlyPromotions::PromotionCategory
         can :manage, SolidusFriendlyPromotions::PromotionCode
       end

data/app/models/solidus_friendly_promotions/promotion.rb

@@ -7,8 +7,8 @@ module SolidusFriendlyPromotions
     belongs_to :category, class_name: "SolidusFriendlyPromotions::PromotionCategory",
       foreign_key: :promotion_category_id, optional: true
     belongs_to :original_promotion, class_name: "Spree::Promotion", optional: true
-    has_many :rules, class_name: "SolidusFriendlyPromotions::PromotionRule", dependent: :destroy
-    has_many :actions, class_name: "SolidusFriendlyPromotions::PromotionAction", dependent: :destroy
+    has_many :benefits, class_name: "SolidusFriendlyPromotions::Benefit", dependent: :destroy
+    has_many :conditions, through: :benefits
     has_many :codes, class_name: "SolidusFriendlyPromotions::PromotionCode", dependent: :destroy
     has_many :code_batches, class_name: "SolidusFriendlyPromotions::PromotionCodeBatch", dependent: :destroy
     has_many :order_promotions, class_name: "SolidusFriendlyPromotions::OrderPromotion", dependent: :destroy
@@ -22,8 +22,9 @@ module SolidusFriendlyPromotions
     validate :apply_automatically_disallowed_with_promotion_codes
 
     before_save :normalize_blank_values
+    after_discard :delete_cart_connections
 
-    scope :active, ->(time = Time.current) { has_actions.started_and_unexpired(time) }
+    scope :active, ->(time = Time.current) { has_benefits.started_and_unexpired(time) }
     scope :advertised, -> { where(advertise: true) }
     scope :coupons, -> { joins(:codes).distinct }
     scope :started_and_unexpired, ->(time = Time.current) do
@@ -32,8 +33,8 @@ module SolidusFriendlyPromotions
       where(table[:starts_at].eq(nil).or(table[:starts_at].lt(time)))
         .where(table[:expires_at].eq(nil).or(table[:expires_at].gt(time)))
     end
-    scope :has_actions, -> do
-      joins(:actions).distinct
+    scope :has_benefits, -> do
+      joins(:benefits).distinct
     end
 
     enum lane: SolidusFriendlyPromotions.config.preferred_lanes
@@ -62,8 +63,8 @@ module SolidusFriendlyPromotions
         .joins(:all_adjustments)
         .where(
           spree_adjustments: {
-            source_type: "SolidusFriendlyPromotions::PromotionAction",
-            source_id: actions.map(&:id),
+            source_type: "SolidusFriendlyPromotions::Benefit",
+            source_id: benefits.map(&:id),
             eligible: true
           }
         ).distinct
@@ -113,7 +114,7 @@ module SolidusFriendlyPromotions
     end
 
     def active?(time = Time.current)
-      started?(time) && not_expired?(time) && actions.present?
+      started?(time) && not_expired?(time) && benefits.present?
     end
 
     def inactive?(time = Time.current)
@@ -125,47 +126,13 @@ module SolidusFriendlyPromotions
     end
 
     def products
-      rules.where(type: "SolidusFriendlyPromotions::Rules::Product").flat_map(&:products).uniq
+      conditions.where(type: "SolidusFriendlyPromotions::Conditions::Product").flat_map(&:products).uniq
     end
 
     def eligibility_results
       @eligibility_results ||= SolidusFriendlyPromotions::EligibilityResults.new(self)
     end
 
-    def eligible_by_applicable_rules?(promotable, dry_run: false)
-      applicable_rules = rules.select do |rule|
-        rule.applicable?(promotable)
-      end
-
-      applicable_rules.map do |applicable_rule|
-        eligible = applicable_rule.eligible?(promotable)
-
-        break [false] if !eligible && !dry_run
-
-        if dry_run
-          if applicable_rule.eligibility_errors.details[:base].first
-            code = applicable_rule.eligibility_errors.details[:base].first[:error_code]
-            message = applicable_rule.eligibility_errors.full_messages.first
-          end
-          eligibility_results.add(
-            item: promotable,
-            rule: applicable_rule,
-            success: eligible,
-            code: eligible ? nil : (code || :coupon_code_unknown_error),
-            message: eligible ? nil : (message || I18n.t(:coupon_code_unknown_error, scope: [:solidus_friendly_promotions, :eligibility_errors]))
-          )
-        end
-
-        eligible
-      end.all?
-    end
-
-    def applicable_line_items(order)
-      order.discountable_line_items.select do |line_item|
-        eligible_by_applicable_rules?(line_item)
-      end
-    end
-
     private
 
     def normalize_blank_values
@@ -183,5 +150,9 @@ module SolidusFriendlyPromotions
 
       errors.add(:apply_automatically, :disallowed_with_promotion_codes) if codes.present?
     end
+
+    def delete_cart_connections
+      order_promotions.where(order: Spree::Order.incomplete).destroy_all
+    end
   end
 end

data/app/models/solidus_friendly_promotions/promotion_advertiser.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class PromotionAdvertiser
+    def self.for_product(product)
+      promotion_ids = ConditionProduct.joins(condition: :benefit).where(product: product).select(:promotion_id).distinct
+      SolidusFriendlyPromotions::Promotion.advertised.where(id: promotion_ids).reject(&:inactive?)
+    end
+  end
+end

data/app/models/solidus_friendly_promotions/promotion_code.rb

@@ -2,7 +2,7 @@
 
 module SolidusFriendlyPromotions
   class PromotionCode < Spree::Base
-    belongs_to :promotion, inverse_of: :codes
+    belongs_to :promotion, -> { with_discarded }, inverse_of: :codes
     belongs_to :promotion_code_batch, inverse_of: :promotion_codes, optional: true
 
     has_many :order_promotions, class_name: "SolidusFriendlyPromotions::OrderPromotion", dependent: :destroy

data/app/models/solidus_friendly_promotions/shipping_rate_discount.rb

@@ -3,7 +3,7 @@
 module SolidusFriendlyPromotions
   class ShippingRateDiscount < Spree::Base
     belongs_to :shipping_rate, inverse_of: :discounts, class_name: "Spree::ShippingRate"
-    belongs_to :promotion_action, inverse_of: :shipping_rate_discounts
+    belongs_to :benefit, inverse_of: :shipping_rate_discounts
 
     extend Spree::DisplayMoney
     money_methods :amount

data/app/views/solidus_friendly_promotions/admin/benefit_fields/_adjust_line_item.html.erb

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

data/app/views/solidus_friendly_promotions/admin/{promotion_actions/actions → benefit_fields}/_adjust_line_item_quantity_groups.html.erb

@@ -1,13 +1,13 @@
-<%= fields_for param_prefix, promotion_action do |form| %>
-  <div class="field">
+<%= 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_friendly_promotions/admin/promotion_actions/actions/calculator_fields",
-  promotion_action: promotion_action,
+  "solidus_friendly_promotions/admin/benefit_fields/calculator_fields",
+  benefit: benefit,
   param_prefix: param_prefix,
   form: form
 ) %>

data/app/views/solidus_friendly_promotions/admin/benefit_fields/_adjust_shipment.html.erb

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

data/app/views/solidus_friendly_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_friendly_promotions/admin/calculator_fields/#{type_name}"], true) %>
+  <%= render "solidus_friendly_promotions/admin/calculator_fields/#{type_name}/fields", calculator: calculator, prefix: param_prefix, form: form %>
+<% else %>
+  <%= render "solidus_friendly_promotions/admin/calculator_fields/default_fields", calculator: calculator, prefix: param_prefix, form: form %>
+<% end %>

data/app/views/solidus_friendly_promotions/admin/{promotion_actions/actions → benefit_fields}/_create_discounted_item.html.erb

@@ -1,19 +1,21 @@
-<%= fields_for param_prefix, promotion_action do |form| %>
-  <div class="field">
+<%= fields_for param_prefix, benefit do |form| %>
+  <div class="form-group">
     <%= form.label :preferred_variant_id %>
-    <%= form.text_field :preferred_variant_id, class: "variant_autocomplete fullwidth" %>
+    <%= 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="field">
+  <div class="form-group">
     <%= form.label :preferred_necessary_quantity %>
     <%= form.number_field :preferred_necessary_quantity, class: "fullwidth" %>
   </div>
 <% end %>
 
 <%= render(
-  "solidus_friendly_promotions/admin/promotion_actions/actions/calculator_fields",
-  promotion_action: promotion_action,
+  "solidus_friendly_promotions/admin/benefit_fields/calculator_fields",
+  benefit: benefit,
   param_prefix: param_prefix,
   form: form
 ) %>

data/app/views/solidus_friendly_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_friendly_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_friendly_promotions/admin/benefits/calculator_select",
+            path: solidus_friendly_promotions.edit_admin_promotion_benefit_path(@promotion, benefit),
+            benefit: benefit %>
+
+          <%=
+            form_with(
+            model: benefit,
+            scope: :benefit,
+            url: solidus_friendly_promotions.admin_promotion_benefit_path(@promotion, benefit),
+            data: { turbo: false }
+          ) do |form| %>
+            <%= render 'solidus_friendly_promotions/admin/benefits/form', form: form %>
+            <div class="row">
+              <div class="col-12">
+                <%= button_tag t(:update, scope: [:solidus_friendly_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_friendly_promotions/admin/conditions/condition', collection: benefit.conditions %>
+
+            <%= turbo_frame_tag benefit, "new_condition" do %>
+              <%= link_to t(:add_condition, scope: :solidus_friendly_promotions), solidus_friendly_promotions.new_admin_promotion_benefit_condition_path(@promotion, benefit), class: 'btn btn-secondary' %>
+            <% end %>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</div>