solidus_friendly_promotions 1.0.0.pre

data/db/migrate/20231012120928_add_db_comments_to_friendly_promotion_categories.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class AddDbCommentsToFriendlyPromotionCategories < ActiveRecord::Migration[6.1]
+  def up
+    if connection.supports_comments?
+      change_table_comment(:friendly_promotion_categories, friendly_promotion_categories_table_comment)
+      change_column_comment(:friendly_promotion_categories, :id, id_comment)
+      change_column_comment(:friendly_promotion_categories, :name, name_comment)
+      change_column_comment(:friendly_promotion_categories, :code, code_comment)
+      change_column_comment(:friendly_promotion_categories, :created_at, created_at_comment)
+      change_column_comment(:friendly_promotion_categories, :updated_at, updated_at_comment)
+    end
+  end
+
+  private
+
+  def friendly_promotion_categories_table_comment
+    <<~COMMENT
+      Category that helps admins index promotions.
+    COMMENT
+  end
+
+  def id_comment
+    <<~COMMENT
+      Primary key of this table.
+    COMMENT
+  end
+
+  def name_comment
+    <<~COMMENT
+      Name of this promotion category.
+    COMMENT
+  end
+
+  def code_comment
+    <<~COMMENT
+      Code of this promotion category.
+    COMMENT
+  end
+
+  def created_at_comment
+    <<~COMMENT
+      Timestamp indicating when this record was created.
+    COMMENT
+  end
+
+  def updated_at_comment
+    <<~COMMENT
+      Timestamp indicating when this record was last updated.
+    COMMENT
+  end
+end

data/db/migrate/20231013181921_add_original_promotion_ids.rb

@@ -0,0 +1,6 @@
+class AddOriginalPromotionIds < ActiveRecord::Migration[7.0]
+  def change
+    add_reference :friendly_promotions, :original_promotion, type: :integer, index: {name: :index_original_promotion_id}, foreign_key: {to_table: :spree_promotions}
+    add_reference :friendly_promotion_actions, :original_promotion_action, type: :integer, index: {name: :index_original_promotion_action_id}, foreign_key: {to_table: :spree_promotion_actions}
+  end
+end

data/lib/generators/solidus_friendly_promotions/install/install_generator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      class_option :auto_run_migrations, type: :boolean, default: false
+      source_root File.expand_path("templates", __dir__)
+
+      def self.exit_on_failure?
+        true
+      end
+
+      def copy_initializer
+        template "initializer.rb", "config/initializers/solidus_friendly_promotions.rb"
+      end
+
+      def add_migrations
+        run "bin/rails railties:install:migrations FROM=solidus_friendly_promotions"
+      end
+
+      def mount_engine
+        inject_into_file "config/routes.rb",
+          "  mount SolidusFriendlyPromotions::Engine => '/'\n",
+          before: /  mount Spree::Core::Engine.*/,
+          verbose: true
+      end
+
+      def run_migrations
+        run_migrations = options[:auto_run_migrations] || ["", "y", "Y"].include?(ask("Would you like to run the migrations now? [Y/n]")) # rubocop:disable Layout/LineLength
+        if run_migrations
+          run "bin/rails db:migrate"
+        else
+          puts "Skipping bin/rails db:migrate, don't forget to run it!" # rubocop:disable Rails/Output
+        end
+      end
+    end
+  end
+end

data/lib/generators/solidus_friendly_promotions/install/templates/initializer.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+# Replace solidus core's order contents and promotion adjuster classes with ours.
+Spree::Config.order_contents_class = "SolidusFriendlyPromotions::SimpleOrderContents"
+Spree::Config.promotion_adjuster_class = "SolidusFriendlyPromotions::FriendlyPromotionAdjuster"
+
+# Replace the promotions menu from core with ours
+Spree::Backend::Config.configure do |config|
+  config.menu_items = config.menu_items.map do |item|
+    next item unless item.label.to_sym == :promotions
+
+    # The API of the MenuItem class changes in Solidus 4.2.0
+    if item.respond_to?(:children)
+      Spree::BackendConfiguration::MenuItem.new(
+        label: :promotions,
+        icon: "bullhorn",
+        condition: -> { can?(:admin, SolidusFriendlyPromotions::Promotion) },
+        url: -> { SolidusFriendlyPromotions::Engine.routes.url_helpers.admin_promotions_path },
+        data_hook: :admin_promotion_sub_tabs,
+        children: [
+          Spree::BackendConfiguration::MenuItem.new(
+            label: :promotions,
+            url: -> { SolidusFriendlyPromotions::Engine.routes.url_helpers.admin_promotions_path },
+            condition: -> { can?(:admin, SolidusFriendlyPromotions::Promotion) }
+          ),
+          Spree::BackendConfiguration::MenuItem.new(
+            label: :promotion_categories,
+            url: -> { SolidusFriendlyPromotions::Engine.routes.url_helpers.admin_promotion_categories_path },
+            condition: -> { can?(:admin, SolidusFriendlyPromotions::PromotionCategory) }
+          ),
+          Spree::BackendConfiguration::MenuItem.new(
+            label: :legacy_promotions,
+            condition: -> { can?(:admin, Spree::Promotion && Spree::Promotion.any?) },
+            url: -> { Spree::Core::Engine.routes.url_helpers.admin_promotions_path },
+            match_path: "/admin/promotions/"
+          ),
+          Spree::BackendConfiguration::MenuItem.new(
+            label: :legacy_promotion_categories,
+            condition: -> { can?(:admin, Spree::PromotionCategory && Spree::Promotion.any?) },
+            url: -> { Spree::Core::Engine.routes.url_helpers.admin_promotion_categories_path },
+            match_path: "/admin/promotion_categories/"
+          )
+        ]
+      )
+    else
+      Spree::BackendConfiguration::MenuItem.new(
+        [:promotions, :promotion_categories],
+        "bullhorn",
+        partial: "solidus_friendly_promotions/admin/shared/promotion_sub_menu",
+        condition: -> { can?(:admin, SolidusFriendlyPromotions::Promotion) },
+        url: -> { SolidusFriendlyPromotions::Engine.routes.url_helpers.admin_promotions_path },
+        position: 2
+      )
+    end
+  end
+end
+
+SolidusFriendlyPromotions.configure do |config|
+  # This class chooses which promotion should apply to a line item in case
+  # that more than one promotion is eligible.
+  config.discount_chooser_class = "SolidusFriendlyPromotions::FriendlyPromotionAdjuster::ChooseDiscounts"
+
+  # How many promotions should be displayed on the index page in the admin.
+  config.promotions_per_page = 25
+
+  config.promotion_calculators = SolidusFriendlyPromotions::NestedClassSet.new(
+    "SolidusFriendlyPromotions::Actions::AdjustShipment" => [
+      "SolidusFriendlyPromotions::Calculators::FlatRate",
+      "SolidusFriendlyPromotions::Calculators::FlexiRate",
+      "SolidusFriendlyPromotions::Calculators::Percent",
+      "SolidusFriendlyPromotions::Calculators::TieredFlatRate",
+      "SolidusFriendlyPromotions::Calculators::TieredPercent"
+    ],
+    "SolidusFriendlyPromotions::Actions::AdjustLineItem" => [
+      "SolidusFriendlyPromotions::Calculators::DistributedAmount",
+      "SolidusFriendlyPromotions::Calculators::FlatRate",
+      "SolidusFriendlyPromotions::Calculators::FlexiRate",
+      "SolidusFriendlyPromotions::Calculators::Percent",
+      "SolidusFriendlyPromotions::Calculators::TieredFlatRate",
+      "SolidusFriendlyPromotions::Calculators::TieredPercent"
+    ],
+    "SolidusFriendlyPromotions::Actions::AdjustLineItemQuantityGroups" => [
+      "SolidusFriendlyPromotions::Calculators::FlatRate",
+      "SolidusFriendlyPromotions::Calculators::Percent"
+    ]
+  )
+
+  config.order_rules = [
+    "SolidusFriendlyPromotions::Rules::FirstOrder",
+    "SolidusFriendlyPromotions::Rules::FirstRepeatPurchaseSince",
+    "SolidusFriendlyPromotions::Rules::ItemTotal",
+    "SolidusFriendlyPromotions::Rules::DiscountedItemTotal",
+    "SolidusFriendlyPromotions::Rules::MinimumQuantity",
+    "SolidusFriendlyPromotions::Rules::NthOrder",
+    "SolidusFriendlyPromotions::Rules::OneUsePerUser",
+    "SolidusFriendlyPromotions::Rules::OptionValue",
+    "SolidusFriendlyPromotions::Rules::Product",
+    "SolidusFriendlyPromotions::Rules::Store",
+    "SolidusFriendlyPromotions::Rules::Taxon",
+    "SolidusFriendlyPromotions::Rules::UserLoggedIn",
+    "SolidusFriendlyPromotions::Rules::UserRole",
+    "SolidusFriendlyPromotions::Rules::User"
+  ]
+  config.line_item_rules = [
+    "SolidusFriendlyPromotions::Rules::LineItemOptionValue",
+    "SolidusFriendlyPromotions::Rules::LineItemProduct",
+    "SolidusFriendlyPromotions::Rules::LineItemTaxon"
+  ]
+  config.shipment_rules = [
+    "SolidusFriendlyPromotions::Rules::ShippingMethod"
+  ]
+
+  config.actions = [
+    "SolidusFriendlyPromotions::Actions::AdjustLineItem",
+    "SolidusFriendlyPromotions::Actions::AdjustLineItemQuantityGroups",
+    "SolidusFriendlyPromotions::Actions::AdjustShipment"
+  ]
+end

data/lib/solidus_friendly_promotions/configuration.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "spree/core/environment_extension"
+
+module SolidusFriendlyPromotions
+  class Configuration < Spree::Preferences::Configuration
+    attr_accessor :sync_order_promotions
+    attr_accessor :promotion_calculators
+
+    def initialize
+      @sync_order_promotions = true
+      @promotion_calculators = NestedClassSet.new
+    end
+
+    include Spree::Core::EnvironmentExtension
+
+    add_class_set :line_item_discount_calculators
+    add_class_set :shipment_discount_calculators
+
+    add_class_set :order_rules
+    add_class_set :line_item_rules
+    add_class_set :shipment_rules
+
+    add_class_set :actions
+
+    class_name_attribute :discount_chooser_class, default: "SolidusFriendlyPromotions::DiscountChooser"
+    class_name_attribute :promotion_code_batch_mailer_class,
+      default: "SolidusFriendlyPromotions::PromotionCodeBatchMailer"
+
+    # @!attribute [rw] promotions_per_page
+    #   @return [Integer] Promotions to show per-page in the admin (default: +25+)
+    preference :promotions_per_page, :integer, default: 25
+
+    preference :lanes, :hash, default: {
+      pre: 0,
+      default: 1,
+      post: 2
+    }
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    alias_method :config, :configuration
+
+    def configure
+      yield configuration
+    end
+  end
+end

data/lib/solidus_friendly_promotions/engine.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "solidus_core"
+require "solidus_support"
+
+module SolidusFriendlyPromotions
+  class Engine < Rails::Engine
+    include SolidusSupport::EngineExtensions
+
+    isolate_namespace ::SolidusFriendlyPromotions
+
+    engine_name "solidus_friendly_promotions"
+
+    # use rspec for tests
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    initializer "solidus_friendly_promotions.assets" do |app|
+      app.config.assets.precompile << "solidus_friendly_promotions/manifest.js"
+    end
+
+    initializer "solidus_friendly_promotions.importmap" do |app|
+      SolidusFriendlyPromotions.importmap.draw(Engine.root.join("config", "importmap.rb"))
+
+      package_path = Engine.root.join("app/javascript")
+      app.config.assets.paths << package_path
+
+      if app.config.importmap.sweep_cache
+        SolidusFriendlyPromotions.importmap.cache_sweeper(watches: package_path)
+        ActiveSupport.on_load(:action_controller_base) do
+          before_action { SolidusFriendlyPromotions.importmap.cache_sweeper.execute_if_updated }
+        end
+      end
+    end
+  end
+end

data/lib/solidus_friendly_promotions/migrate_adjustments.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class MigrateAdjustments
+    class << self
+      def up
+        sql = if ActiveRecord::Base.connection_db_config.adapter == "mysql2"
+          <<~SQL
+            UPDATE spree_adjustments
+              INNER JOIN spree_promotion_actions ON spree_adjustments.source_id = spree_promotion_actions.id and spree_adjustments.source_type = 'Spree::PromotionAction'
+              INNER JOIN friendly_promotion_actions ON friendly_promotion_actions.original_promotion_action_id = spree_promotion_actions.id
+            SET source_id = friendly_promotion_actions.id,
+              source_type = 'SolidusFriendlyPromotions::PromotionAction'
+          SQL
+        else
+          <<~SQL
+            UPDATE spree_adjustments
+            SET source_id = friendly_promotion_actions.id,
+              source_type = 'SolidusFriendlyPromotions::PromotionAction'
+            FROM spree_promotion_actions
+              INNER JOIN friendly_promotion_actions ON friendly_promotion_actions.original_promotion_action_id = spree_promotion_actions.id
+            WHERE spree_adjustments.source_id = spree_promotion_actions.id and spree_adjustments.source_type = 'Spree::PromotionAction'
+          SQL
+        end
+
+        execute(sql)
+      end
+
+      def down
+        sql = if ActiveRecord::Base.connection_db_config.adapter == "mysql2"
+          <<~SQL
+            UPDATE spree_adjustments
+              INNER JOIN friendly_promotion_actions 
+              INNER JOIN spree_promotion_actions ON spree_adjustments.source_id = friendly_promotion_actions.id and spree_adjustments.source_type = 'SolidusFriendlyPromotions::PromotionAction'
+            SET source_id = spree_promotion_actions.id,
+              source_type = 'Spree::PromotionAction'
+            WHERE friendly_promotion_actions.original_promotion_action_id = spree_promotion_actions.id
+          SQL
+        else
+          <<~SQL
+            UPDATE spree_adjustments
+            SET source_id = spree_promotion_actions.id,
+                source_type = 'Spree::PromotionAction'
+            FROM spree_promotion_actions
+              INNER JOIN friendly_promotion_actions ON friendly_promotion_actions.original_promotion_action_id = spree_promotion_actions.id
+            WHERE spree_adjustments.source_id = friendly_promotion_actions.id and spree_adjustments.source_type = 'SolidusFriendlyPromotions::PromotionAction'
+          SQL
+        end
+
+        execute(sql)
+      end
+
+      private
+
+      def execute(sql)
+        Spree::Adjustment.transaction do
+          ActiveRecord::Base.connection.execute(sql)
+        end
+      end
+    end
+  end
+end

data/lib/solidus_friendly_promotions/migrate_order_promotions.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class MigrateOrderPromotions
+    class << self
+      def up
+        sql = <<~SQL
+          INSERT INTO friendly_order_promotions (
+            order_id,
+            promotion_id,
+            promotion_code_id,
+            created_at,
+            updated_at
+          )
+          SELECT
+            spree_orders_promotions.order_id AS order_id,
+            friendly_promotions.id AS promotion_id,
+            friendly_promotion_codes.id AS promotion_code_id,
+            spree_orders_promotions.created_at,
+            spree_orders_promotions.updated_at
+          FROM spree_orders_promotions
+            INNER JOIN spree_promotions ON spree_orders_promotions.promotion_id = spree_promotions.id
+            INNER JOIN friendly_promotions ON spree_promotions.id = friendly_promotions.original_promotion_id
+            LEFT OUTER JOIN spree_promotion_codes ON spree_orders_promotions.promotion_code_id = spree_promotion_codes.id
+            LEFT OUTER JOIN friendly_promotion_codes ON spree_promotion_codes.value = friendly_promotion_codes.value
+          WHERE NOT EXISTS (
+            SELECT NULL
+            FROM friendly_order_promotions
+            WHERE friendly_order_promotions.order_id = order_id
+              AND (friendly_order_promotions.promotion_code_id = promotion_code_id OR promotion_code_id IS NULL)
+              AND friendly_order_promotions.promotion_id = promotion_id
+          );
+        SQL
+        ActiveRecord::Base.connection.execute(sql)
+
+        Spree::OrderPromotion.delete_all
+      end
+
+      def down
+        sql = <<~SQL
+          INSERT INTO spree_orders_promotions (
+            order_id,
+            promotion_id,
+            promotion_code_id,
+            created_at,
+            updated_at
+          )
+          SELECT
+            friendly_order_promotions.order_id AS order_id,
+            spree_promotions.id AS promotion_id,
+            spree_promotion_codes.id AS promotion_code_id,
+            friendly_order_promotions.created_at,
+            friendly_order_promotions.updated_at
+          FROM friendly_order_promotions
+            INNER JOIN friendly_promotions ON friendly_order_promotions.promotion_id = friendly_promotions.id
+            INNER JOIN spree_promotions ON spree_promotions.id = friendly_promotions.original_promotion_id
+            LEFT OUTER JOIN friendly_promotion_codes ON friendly_order_promotions.promotion_code_id = friendly_promotion_codes.id
+            LEFT OUTER JOIN spree_promotion_codes ON spree_promotion_codes.value = friendly_promotion_codes.value
+          WHERE NOT EXISTS (
+            SELECT NULL
+            FROM spree_orders_promotions
+            WHERE spree_orders_promotions.order_id = order_id
+              AND (spree_orders_promotions.promotion_code_id = promotion_code_id OR promotion_code_id IS NULL)
+              AND spree_orders_promotions.promotion_id = promotion_id
+          );
+        SQL
+        ActiveRecord::Base.connection.execute(sql)
+
+        SolidusFriendlyPromotions::OrderPromotion.delete_all
+      end
+    end
+  end
+end

data/lib/solidus_friendly_promotions/nested_class_set.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "spree/core/class_constantizer"
+
+module SolidusFriendlyPromotions
+  class NestedClassSet
+    attr_reader :klass_sets
+
+    def initialize(hash = {})
+      @klass_sets = hash.map do |key, value|
+        [
+          key,
+          Spree::Core::ClassConstantizer::Set.new.tap do |set|
+            value.each { |klass_name| set << klass_name }
+          end
+        ]
+      end.to_h
+    end
+
+    def [](klass)
+      klass_sets[klass.name]
+    end
+  end
+end

data/lib/solidus_friendly_promotions/promotion_map.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  PROMOTION_MAP = {
+    rules: {
+      Spree::Promotion::Rules::ItemTotal =>
+        SolidusFriendlyPromotions::Rules::ItemTotal,
+      Spree::Promotion::Rules::Product =>
+        SolidusFriendlyPromotions::Rules::Product,
+      Spree::Promotion::Rules::User =>
+        SolidusFriendlyPromotions::Rules::User,
+      Spree::Promotion::Rules::FirstOrder =>
+        SolidusFriendlyPromotions::Rules::FirstOrder,
+      Spree::Promotion::Rules::UserLoggedIn =>
+        SolidusFriendlyPromotions::Rules::UserLoggedIn,
+      Spree::Promotion::Rules::OneUsePerUser =>
+        SolidusFriendlyPromotions::Rules::OneUsePerUser,
+      Spree::Promotion::Rules::Taxon =>
+        SolidusFriendlyPromotions::Rules::Taxon,
+      Spree::Promotion::Rules::NthOrder =>
+        SolidusFriendlyPromotions::Rules::NthOrder,
+      Spree::Promotion::Rules::OptionValue =>
+        SolidusFriendlyPromotions::Rules::OptionValue,
+      Spree::Promotion::Rules::FirstRepeatPurchaseSince =>
+        SolidusFriendlyPromotions::Rules::FirstRepeatPurchaseSince,
+      Spree::Promotion::Rules::UserRole =>
+        SolidusFriendlyPromotions::Rules::UserRole,
+      Spree::Promotion::Rules::Store =>
+        SolidusFriendlyPromotions::Rules::Store
+    },
+    actions: {
+      Spree::Promotion::Actions::CreateAdjustment => ->(old_action) {
+        calculator = case old_action.calculator
+        when Spree::Calculator::FlatRate
+          SolidusFriendlyPromotions::Calculators::DistributedAmount.new(preferences: old_action.calculator.preferences)
+        when Spree::Calculator::FlatPercentItemTotal
+          SolidusFriendlyPromotions::Calculators::Percent.new(preferred_percent: old_action.calculator.preferred_flat_percent)
+        end
+
+        SolidusFriendlyPromotions::Actions::AdjustLineItem.new(
+          calculator: calculator
+        )
+      },
+      Spree::Promotion::Actions::CreateItemAdjustments => ->(old_action) {
+        preferences = old_action.calculator.preferences
+        calculator = case old_action.calculator
+        when Spree::Calculator::FlatRate
+          SolidusFriendlyPromotions::Calculators::FlatRate.new(preferences: preferences)
+        when Spree::Calculator::PercentOnLineItem
+          SolidusFriendlyPromotions::Calculators::Percent.new(preferences: preferences)
+        when Spree::Calculator::FlexiRate
+          SolidusFriendlyPromotions::Calculators::FlexiRate.new(preferences: preferences)
+        when Spree::Calculator::DistributedAmount
+          SolidusFriendlyPromotions::Calculators::DistributedAmount.new(preferences: preferences)
+        when Spree::Calculator::TieredFlatRate
+          SolidusFriendlyPromotions::Calculators::TieredFlatRate.new(preferences: preferences)
+        when Spree::Calculator::TieredPercent
+          SolidusFriendlyPromotions::Calculators::TieredPercent.new(preferences: preferences)
+        end
+
+        SolidusFriendlyPromotions::Actions::AdjustLineItem.new(
+          calculator: calculator
+        )
+      },
+      Spree::Promotion::Actions::CreateQuantityAdjustments => ->(old_action) {
+        preferences = old_action.calculator.preferences
+        calculator = case old_action.calculator
+        when Spree::Calculator::FlatRate
+          SolidusFriendlyPromotions::Calculators::FlatRate.new(preferences: preferences)
+        when Spree::Calculator::PercentOnLineItem
+          SolidusFriendlyPromotions::Calculators::Percent.new(preferences: preferences)
+        when Spree::Calculator::FlexiRate
+          SolidusFriendlyPromotions::Calculators::FlexiRate.new(preferences: preferences)
+        when Spree::Calculator::DistributedAmount
+          SolidusFriendlyPromotions::Calculators::DistributedAmount.new(preferences: preferences)
+        when Spree::Calculator::TieredFlatRate
+          SolidusFriendlyPromotions::Calculators::TieredFlatRate.new(preferences: preferences)
+        when Spree::Calculator::TieredPercent
+          SolidusFriendlyPromotions::Calculators::TieredPercent.new(preferences: preferences)
+        end
+
+        SolidusFriendlyPromotions::Actions::AdjustLineItemQuantityGroups.new(
+          preferred_group_size: old_action.preferred_group_size,
+          calculator: calculator
+        )
+      },
+      Spree::Promotion::Actions::FreeShipping => ->(old_action) {
+        SolidusFriendlyPromotions::Actions::AdjustShipment.new(
+          calculator: SolidusFriendlyPromotions::Calculators::Percent.new(
+            preferred_percent: 100
+          )
+        )
+      }
+    }
+  }
+end

data/lib/solidus_friendly_promotions/promotion_migrator.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module SolidusFriendlyPromotions
+  class PromotionMigrator
+    PROMOTION_IGNORED_ATTRIBUTES = ["id", "type", "promotion_category_id"]
+
+    attr_reader :promotion_map
+
+    def initialize(promotion_map)
+      @promotion_map = promotion_map
+    end
+
+    def call
+      SolidusFriendlyPromotions::PromotionCategory.destroy_all
+      Spree::PromotionCategory.all.each do |promotion_category|
+        SolidusFriendlyPromotions::PromotionCategory.create!(promotion_category.attributes.except("id"))
+      end
+
+      SolidusFriendlyPromotions::Promotion.destroy_all
+      Spree::Promotion.all.each do |promotion|
+        new_promotion = copy_promotion(promotion)
+        if promotion.promotion_category&.name.present?
+          new_promotion.category = SolidusFriendlyPromotions::PromotionCategory.find_by(
+            name: promotion.promotion_category.name
+          )
+        end
+        new_promotion.rules = promotion.rules.flat_map do |old_promotion_rule|
+          generate_new_promotion_rules(old_promotion_rule)
+        end
+        new_promotion.actions = promotion.actions.flat_map do |old_promotion_action|
+          generate_new_promotion_actions(old_promotion_action)&.tap do |new_promotion_action|
+            new_promotion_action.original_promotion_action = old_promotion_action
+          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 friendly_promotion_code_batches (promotion_id, base_code, number_of_codes, email, error, state, created_at, updated_at, join_characters)
+        SELECT friendly_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 friendly_promotions ON spree_promotions.id = friendly_promotions.original_promotion_id
+        WHERE spree_promotion_code_batches.promotion_id = #{new_promotion.original_promotion_id};
+      SQL
+      SolidusFriendlyPromotions::PromotionCodeBatch.connection.execute(sql)
+    end
+
+    def copy_promotion_codes(new_promotion)
+      sql = <<~SQL
+        INSERT INTO friendly_promotion_codes (promotion_id, promotion_code_batch_id, value, created_at, updated_at)
+        SELECT friendly_promotions.id AS promotion_id, friendly_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 friendly_promotion_code_batches ON friendly_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 friendly_promotions ON spree_promotions.id = friendly_promotions.original_promotion_id
+        WHERE spree_promotion_codes.promotion_id = #{new_promotion.original_promotion_id};
+      SQL
+      SolidusFriendlyPromotions::PromotionCode.connection.execute(sql)
+    end
+
+    def copy_promotion(old_promotion)
+      SolidusFriendlyPromotions::Promotion.new(
+        old_promotion.attributes.except(*PROMOTION_IGNORED_ATTRIBUTES).merge(
+          customer_label: old_promotion.name,
+          original_promotion: old_promotion
+        )
+      )
+    end
+
+    def generate_new_promotion_actions(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_rules(old_promotion_rule)
+      new_promo_rule_class = promotion_map[:rules][old_promotion_rule.class]
+      if new_promo_rule_class.nil?
+        puts("#{old_promotion_rule.class} is not supported")
+        []
+      elsif new_promo_rule_class.respond_to?(:call)
+        new_promo_rule_class.call(old_promotion_rule)
+      else
+        new_rule = new_promo_rule_class.new(old_promotion_rule.attributes.except(*PROMOTION_IGNORED_ATTRIBUTES))
+        new_rule.preload_relations.each do |relation|
+          new_rule.send("#{relation}=", old_promotion_rule.send(relation))
+        end
+        [new_rule]
+      end
+    end
+  end
+end