discourse/lib/import_export/importer.rb

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

272 lines
7.8 KiB
Ruby
Raw Normal View History

# frozen_string_literal: true
require File.join(Rails.root, "script", "import_scripts", "base.rb")
module ImportExport
class Importer < ImportScripts::Base
def initialize(data)
@users = data[:users]
@groups = data[:groups]
@categories = data[:categories]
@topics = data[:topics]
@translation_overrides = data[:translation_overrides]
# To support legacy `category_export` script
if data[:category].present?
@categories = [] if @categories.blank?
@categories << data[:category]
end
end
def perform
RateLimiter.disable
import_users
import_groups
import_categories
import_topics
import_translation_overrides
self
ensure
RateLimiter.enable
end
def import_users
return if @users.blank?
puts "Importing users..."
@users.each do |u|
import_id = "#{u[:id]}#{import_source}"
existing = User.with_email(u[:email]).first
if existing
if existing.custom_fields["import_id"] != import_id
existing.custom_fields["import_id"] = import_id
existing.save!
end
else
u = create_user(u, import_id) # see ImportScripts::Base
end
end
self
end
def import_groups
return if @groups.blank?
puts "Importing groups..."
@groups.each do |group_data|
g = group_data.dup
user_ids = g.delete(:user_ids)
external_id = g.delete(:id)
new_group = Group.find_by_name(g[:name]) || Group.create!(g)
user_ids.each do |external_user_id|
begin
new_group.add(User.find(new_user_id(external_user_id)))
rescue StandardError
ActiveRecord::RecordNotUnique
end
end
end
self
end
def import_categories
return if @categories.blank?
puts "Importing categories..."
import_ids = @categories.collect { |c| "#{c[:id]}#{import_source}" }
existing_categories =
CategoryCustomField
.where("name = 'import_id' AND value IN (?)", import_ids)
.select(:category_id, :value)
.to_a
existing_category_ids = existing_categories.pluck(:value)
levels = category_levels
max_level = levels.values.max
if SiteSetting.max_category_nesting < max_level
puts "Setting max_category_nesting to #{max_level}..."
SiteSetting.max_category_nesting = max_level
end
fix_permissions
@categories.reject! { |c| existing_category_ids.include? c[:id].to_s }
@categories.sort_by! { |c| levels[c[:id]] || 0 }
@categories.each do |cat_attrs|
begin
id = cat_attrs.delete(:id)
permissions = cat_attrs.delete(:permissions_params)
category = Category.new(cat_attrs)
category.parent_category_id =
new_category_id(cat_attrs[:parent_category_id]) if cat_attrs[
:parent_category_id
].present?
category.user_id = new_user_id(cat_attrs[:user_id])
import_id = "#{id}#{import_source}"
category.custom_fields["import_id"] = import_id
category.permissions = permissions
category.save!
existing_categories << { category_id: category.id, value: import_id }
if cat_attrs[:description].present?
post = category.topic.ordered_posts.first
post.raw = cat_attrs[:description]
post.skip_validation = true
post.save!
post.rebake!
end
rescue => e
puts "Failed to import category (ID = #{id}, name = #{cat_attrs[:name]}): #{e.message}"
end
end
self
end
def import_topics
return if @topics.blank?
puts "Importing topics...", ""
@topics.each do |t|
puts ""
print t[:title]
first_post_attrs =
t[:posts].first.merge(t.slice(*(TopicExporter::TOPIC_ATTRS - %i[id category_id])))
first_post_attrs[:user_id] = new_user_id(first_post_attrs[:user_id])
first_post_attrs[:category] = new_category_id(t[:category_id])
import_id = "#{first_post_attrs[:id]}#{import_source}"
first_post = PostCustomField.where(name: "import_id", value: import_id).first&.post
first_post = create_post(first_post_attrs, import_id) unless first_post
topic_id = first_post.topic_id
t[:posts].each_with_index do |post_data, i|
next if i == 0
print "."
post_import_id = "#{post_data[:id]}#{import_source}"
existing = PostCustomField.where(name: "import_id", value: post_import_id).first&.post
unless existing
# see ImportScripts::Base
create_post(
post_data.merge(topic_id: topic_id, user_id: new_user_id(post_data[:user_id])),
post_import_id,
)
end
end
end
puts ""
self
end
def import_translation_overrides
return if @translation_overrides.blank?
puts "Importing translation overrides..."
@translation_overrides.each do |tu|
TranslationOverride.upsert!(tu[:locale], tu[:translation_key], tu[:value])
end
TranslationOverride.reload_all_overrides!
end
def new_user_id(external_user_id)
ucf =
UserCustomField.where(name: "import_id", value: "#{external_user_id}#{import_source}").first
ucf ? ucf.user_id : Discourse::SYSTEM_USER_ID
end
def new_category_id(external_category_id)
CategoryCustomField
.where(name: "import_id", value: "#{external_category_id}#{import_source}")
.first
&.category_id
end
def import_source
@_import_source ||= "#{ENV["IMPORT_SOURCE"] || ""}"
end
def category_levels
@levels ||=
begin
levels = {}
# Incomplete backups may lack definitions for some parent categories
# which would cause an infinite loop below.
parent_ids = @categories.map { |category| category[:parent_category_id] }.uniq
category_ids = @categories.map { |category| category[:id] }.uniq
(parent_ids - category_ids).each { |id| levels[id] = 0 }
loop do
changed = false
@categories.each do |category|
if !levels[category[:id]]
if !category[:parent_category_id]
levels[category[:id]] = 1
elsif levels[category[:parent_category_id]]
levels[category[:id]] = levels[category[:parent_category_id]] + 1
end
changed = true
end
end
break if !changed
end
levels
end
end
def fix_permissions
categories_by_id = @categories.to_h { |category| [category[:id], category] }
@categories.each do |category|
if category[:permissions_params].blank?
category[:permissions_params] = { "everyone" => CategoryGroup.permission_types[:full] }
end
end
max_level = category_levels.values.max
max_level.times do
@categories.each do |category|
parent_category = categories_by_id[category[:parent_category_id]]
if !parent_category || !parent_category[:permissions_params] ||
parent_category[:permissions_params][:everyone]
next
end
parent_groups = parent_category[:permissions_params].map(&:first)
child_groups = category[:permissions_params].map(&:first)
only_subcategory_groups = child_groups - parent_groups
if only_subcategory_groups.present?
parent_category[:permissions_params].merge!(
category[:permissions_params].slice(*only_subcategory_groups),
)
end
end
end
end
end
end