Class: Jobs::ExportUserArchive

Inherits:

Base

• Object
• Base
• Jobs::ExportUserArchive

Defined in:

app/jobs/regular/export_user_archive.rb

Instance Attribute Summary

• #current_user ⇒ Object

  Returns the value of attribute current_user.

• #extra ⇒ Object

  note: contents provided entirely by user.

Instance Method Summary

• #auth_token_logs_export ⇒ Object
• #auth_tokens_export ⇒ Object
• #badges_export ⇒ Object
• #bookmarks_export ⇒ Object
• #category_preferences_export ⇒ Object
• #execute(args) ⇒ Object
• #flags_export ⇒ Object
• #get_header(entity) ⇒ Object
• #include_auth_token_logs? ⇒ Boolean
• #include_post_actions? ⇒ Boolean
• #likes_export ⇒ Object
• #post_actions_export ⇒ Object
• #preferences_export ⇒ Object
• #preferences_filetype ⇒ Object
• #queued_posts_export ⇒ Object
• #user_archive_export ⇒ Object
• #user_archive_profile_export ⇒ Object
• #visits_export ⇒ Object

Methods inherited from Base

acquire_cluster_concurrency_lock!, clear_cluster_concurrency_lock!, cluster_concurrency, cluster_concurrency_redis_key, delayed_perform, #error_context, get_cluster_concurrency, #last_db_duration, #log, #perform, #perform_immediately

Instance Attribute Details

#current_user ⇒ Object

Returns the value of attribute current_user.

# File 'app/jobs/regular/export_user_archive.rb', line 9

def current_user
  @current_user
end

#extra ⇒ Object

note: contents provided entirely by user

# File 'app/jobs/regular/export_user_archive.rb', line 11

def extra
  @extra
end

Instance Method Details

#auth_token_logs_export ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 264

def auth_token_logs_export
  return enum_for(:auth_token_logs) unless block_given?

  UserAuthTokenLog
    .where(user_id: @current_user.id)
    .each do |log|
      yield(
        [
          log.id,
          log.action,
          log.user_auth_token_id,
          log.client_ip,
          log.auth_token.to_s[0..4] + "...", # hashed and truncated
          log.created_at,
          log.path,
          log.user_agent,
        ]
      )
    end
end

#auth_tokens_export ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 236

def auth_tokens_export
  return enum_for(:auth_tokens) unless block_given?

  UserAuthToken
    .where(user_id: @current_user.id)
    .each do |token|
      yield(
        [
          token.id,
          token.auth_token.to_s[0..4] + "...", # hashed and truncated
          token.prev_auth_token[0..4] + "...",
          token.auth_token_seen,
          token.client_ip,
          token.user_agent,
          token.seen_at,
          token.rotated_at,
          token.created_at,
          token.updated_at,
        ]
      )
    end
end

#badges_export ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 285

def badges_export
  return enum_for(:badges_export) unless block_given?

  UserBadge
    .where(user_id: @current_user.id)
    .joins(:badge)
    .select(
      :badge_id,
      :granted_at,
      :post_id,
      :seq,
      :granted_by_id,
      :notification_id,
      :featured_rank,
    )
    .order(:granted_at)
    .each do |ub|
      yield(
        [
          ub.badge_id,
          ub.badge.display_name,
          ub.granted_at,
          ub.post_id,
          ub.seq,
          # Hide the admin's identity, simply indicate human or system
          User.human_user_id?(ub.granted_by_id),
          ub.notification_id,
          ub.featured_rank,
        ]
      )
    end
end

#bookmarks_export ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 318

def bookmarks_export
  return enum_for(:bookmarks_export) unless block_given?

  @current_user
    .bookmarks
    .where.not(bookmarkable_type: nil)
    .order(:id)
    .each do |bookmark|
      link = ""
      if guardian.can_see_bookmarkable?(bookmark)
        if bookmark.bookmarkable.respond_to?(:full_url)
          link = bookmark.bookmarkable.full_url
        else
          link = bookmark.bookmarkable.url
        end
      end

      yield(
        [
          bookmark.bookmarkable_id,
          bookmark.bookmarkable_type,
          link,
          bookmark.name,
          bookmark.created_at,
          bookmark.updated_at,
          bookmark.reminder_at,
          bookmark.reminder_last_sent_at,
          bookmark.reminder_set_at,
          Bookmark.auto_delete_preferences[bookmark.auto_delete_preference],
        ]
      )
    end
end

#category_preferences_export ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 352

def category_preferences_export
  return enum_for(:category_preferences_export) unless block_given?

  CategoryUser
    .where(user_id: @current_user.id)
    .includes(:category)
    .merge(Category.secured(guardian))
    .each do |cu|
      yield(
        [
          cu.category_id,
          piped_category_name(cu.category_id, cu.category),
          NotificationLevels.all[cu.notification_level],
          cu.last_seen_at,
        ]
      )
    end
end

#execute(args) ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 119

def execute(args)
  @current_user = User.find_by(id: args[:user_id])
  @extra = HashWithIndifferentAccess.new(args[:args]) if args[:args]
  @timestamp ||= Time.now.strftime("%y%m%d-%H%M%S")

  components = []

  COMPONENTS.each do |name|
    export_method = "#{name}_export"
    h = { name: name, method: :"#{export_method}" }
    h[:filetype] = :csv
    filetype_method = :"#{name}_filetype"
    h[:filetype] = public_send(filetype_method) if respond_to? filetype_method
    condition_method = :"include_#{name}?"
    h[:skip] = !public_send(condition_method) if respond_to? condition_method
    h[:filename] = name
    components.push(h)
  end

  export_title = "user_archive".titleize
  filename = "user_archive-#{@current_user.username}-#{@timestamp}"
  user_export = UserExport.create(file_name: filename, user_id: @current_user.id)

  filename = "#{filename}-#{user_export.id}"
  dirname = "#{UserExport.base_directory}/#{filename}"

  # ensure directory exists
  FileUtils.mkdir_p(dirname) unless Dir.exist?(dirname)

  # Generate a compressed CSV file
  zip_filename = nil
  begin
    components.each do |component|
      next if component[:skip]
      case component[:filetype]
      when :csv
        CSV.open("#{dirname}/#{component[:filename]}.csv", "w") do |csv|
          csv << get_header(component[:name])
          public_send(component[:method]) { |d| csv << d }
        end
      when :json
        File.open("#{dirname}/#{component[:filename]}.json", "w") do |file|
          file.write MultiJson.dump(public_send(component[:method]), indent: 4)
        end
      else
        raise "unknown export filetype"
      end
    end

    zip_filename = Compression::Zip.new.compress(UserExport.base_directory, filename)
  ensure
    FileUtils.rm_rf(dirname)
  end

  # create upload
  upload = nil

  if File.exist?(zip_filename)
    File.open(zip_filename) do |file|
      upload =
        UploadCreator.new(
          file,
          File.basename(zip_filename),
          type: "csv_export",
          for_export: "true",
        ).create_for(@current_user.id)

      if upload.persisted?
        user_export.update_columns(upload_id: upload.id)
      else
        Rails.logger.warn(
          "Failed to upload the file #{zip_filename}: #{upload.errors.full_messages}",
        )
      end
    end

    File.delete(zip_filename)
  end
ensure
  post = notify_user(upload, export_title)

  if user_export.present? && post.present?
    topic = post.topic
    user_export.update_columns(topic_id: topic.id)
    topic.update_status("closed", true, Discourse.system_user)
  end
end

#flags_export ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 371

def flags_export
  return enum_for(:flags_export) unless block_given?

  PostAction
    .with_deleted
    .where(user_id: @current_user.id)
    .where(post_action_type_id: PostActionType.flag_types.values)
    .order(:created_at)
    .each do |pa|
      yield(
        [
          pa.id,
          pa.post_id,
          PostActionType.flag_types[pa.post_action_type_id],
          pa.created_at,
          pa.updated_at,
          pa.deleted_at,
          self_or_other(pa.deleted_by_id),
          pa.related_post_id,
          pa.targets_topic,
          # renamed to 'was_take_action' to avoid possibility of thinking this is a synonym of agreed_at
          pa.staff_took_action,
        ]
      )
    end
end

#get_header(entity) ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 487

def get_header(entity)
  if entity == "user_list"
    header_array =
      HEADER_ATTRS_FOR["user_list"] + HEADER_ATTRS_FOR["user_stats"] +
        HEADER_ATTRS_FOR["user_profile"]
    header_array.concat(HEADER_ATTRS_FOR["user_sso"]) if SiteSetting.enable_discourse_connect
    user_custom_fields = UserField.all
    if user_custom_fields.present?
      user_custom_fields.each do |custom_field|
        header_array.push("#{custom_field.name} (custom user field)")
      end
    end
    header_array.push("group_names")
  else
    header_array = HEADER_ATTRS_FOR[entity]
  end

  header_array
end

#include_auth_token_logs? ⇒ Boolean

Returns:

• (Boolean)

# File 'app/jobs/regular/export_user_archive.rb', line 259

def include_auth_token_logs?
  # SiteSetting.verbose_auth_token_logging
  UserAuthTokenLog.where(user_id: @current_user.id).exists?
end

#include_post_actions? ⇒ Boolean

Returns:

• (Boolean)

# File 'app/jobs/regular/export_user_archive.rb', line 422

def include_post_actions?
  # Most forums should not have post_action records other than flags and likes, but they are possible in historical oddities.
  PostAction
    .where(user_id: @current_user.id)
    .where.not(
      post_action_type_id: PostActionType.flag_types.values + [PostActionType.types[:like]],
    )
    .exists?
end

#likes_export ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 398

def likes_export
  return enum_for(:likes_export) unless block_given?
  PostAction
    .with_deleted
    .where(user_id: @current_user.id)
    .where(post_action_type_id: PostActionType.types[:like])
    .order(:created_at)
    .each do |pa|
      post = Post.with_deleted.find_by(id: pa.post_id)
      yield(
        [
          pa.id,
          pa.post_id,
          post&.topic_id,
          post&.post_number,
          pa.created_at,
          pa.updated_at,
          pa.deleted_at,
          self_or_other(pa.deleted_by_id),
        ]
      )
    end
end

#post_actions_export ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 432

def post_actions_export
  return enum_for(:likes_export) unless block_given?
  PostAction
    .with_deleted
    .where(user_id: @current_user.id)
    .where.not(
      post_action_type_id: PostActionType.flag_types.values + [PostActionType.types[:like]],
    )
    .order(:created_at)
    .each do |pa|
      yield(
        [
          pa.id,
          pa.post_id,
          PostActionType.types[pa.post_action_type] || pa.post_action_type,
          pa.created_at,
          pa.updated_at,
          pa.deleted_at,
          self_or_other(pa.deleted_by_id),
          pa.related_post_id,
        ]
      )
    end
end

#preferences_export ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 228

def preferences_export
  UserSerializer.new(@current_user, scope: guardian)
end

#preferences_filetype ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 232

def preferences_filetype
  :json
end

#queued_posts_export ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 457

def queued_posts_export
  return enum_for(:queued_posts_export) unless block_given?

  # Most Reviewable fields staff-private, but post content needs to be exported.
  ReviewableQueuedPost
    .where(target_created_by_id: @current_user.id)
    .order(:created_at)
    .each do |rev|
      yield(
        [
          rev.id,
          rev.status,
          rev.category_id,
          rev.topic_id,
          rev.payload["raw"],
          MultiJson.dump(rev.payload.slice(*queued_posts_payload_permitted_keys)),
        ]
      )
    end
end

#user_archive_export ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 207

def user_archive_export
  return enum_for(:user_archive_export) unless block_given?

  Post
    .includes(topic: :category)
    .where(user_id: @current_user.id)
    .select(:topic_id, :post_number, :raw, :cooked, :like_count, :reply_count, :created_at)
    .order(:created_at)
    .with_deleted
    .each { |user_archive| yield get_user_archive_fields(user_archive) }
end

#user_archive_profile_export ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 219

def user_archive_profile_export
  return enum_for(:user_archive_profile_export) unless block_given?

  UserProfile
    .where(user_id: @current_user.id)
    .select(:location, :website, :bio_raw, :views)
    .each { |user_profile| yield get_user_archive_profile_fields(user_profile) }
end

#visits_export ⇒ Object

# File 'app/jobs/regular/export_user_archive.rb', line 478

def visits_export
  return enum_for(:visits_export) unless block_given?

  UserVisit
    .where(user_id: @current_user.id)
    .order(visited_at: :asc)
    .each { |uv| yield [uv.visited_at, uv.posts_read, uv.mobile, uv.time_read] }
end