ActiveAdminImport

Installation

gem "active_admin_import"

gem "active_admin_import" , github: "activeadmin-plugins/active_admin_import"

$ bundle

Features

Basic usage

ActiveAdmin.register Post do
 active_admin_import options
end

Options

Custom ImportResult

class ImportResultWithIds < ActiveAdminImport::ImportResult
 attr_reader :ids
 def initialize
 super
 @ids = []
 end
 def add(batch_result, qty)
 super
 @ids.concat(Array(batch_result.ids))
 end
end
ActiveAdmin.register Author do
 active_admin_import result_class: ImportResultWithIds do |result, options|
 EnqueueAuthorsJob.perform_later(result.ids) if result.imported?
 instance_exec(result, options, &ActiveAdminImport::DSL::DEFAULT_RESULT_PROC)
 end
end

Authorization

class Ability
 include CanCan::Ability
 def initialize(user)
 can :import, Post
 end
end

Per-request context

ActiveAdmin.register PostComment do
 belongs_to :post
 controller do
 def active_admin_import_context
 { post_id: parent.id, request_ip: request.remote_ip }
 end
 end
 active_admin_import before_batch_import: ->(importer) {
 importer.csv_lines.map! { |row| row << importer.model.post_id }
 importer.headers.merge!(:'Post Id' => :post_id)
 }
end

Examples

Files without CSV headers

ActiveAdmin.register Post do
 active_admin_import validate: true,
 template_object: ActiveAdminImport::Model.new(
 hint: "expected header order: body, title, author",
 csv_headers: %w[body title author]
 )
end

Auto-detect file encoding

ActiveAdmin.register Post do
 active_admin_import validate: true,
 template_object: ActiveAdminImport::Model.new(force_encoding: :auto)
end

Force a specific (non-UTF-8) encoding

ActiveAdmin.register Post do
 active_admin_import validate: true,
 template_object: ActiveAdminImport::Model.new(
 hint: "file is encoded in ISO-8859-1",
 force_encoding: "ISO-8859-1"
 )
end

Disallow ZIP upload

ActiveAdmin.register Post do
 active_admin_import validate: true,
 template_object: ActiveAdminImport::Model.new(
 hint: "upload a CSV file",
 allow_archive: false
 )
end

Skip CSV columns

ActiveAdmin.register Post do
 active_admin_import before_batch_import: ->(importer) {
 importer.batch_slice_columns(['name', 'last_name'])
 }
end

Resolve associations on the fly

ActiveAdmin.register Post do
 active_admin_import validate: true,
 headers_rewrites: { 'Author name': :author_id },
 before_batch_import: ->(importer) {
 names = importer.values_at(:author_id)
 mapping = Author.where(name: names).pluck(:name, :id).to_h
 importer.batch_replace(:author_id, mapping)
 }
end

Update existing records by id

Native upsert (recommended where supported)

# PostgreSQL / SQLite
on_duplicate_key_update: { conflict_target: [:id], columns: %i[name last_name birthday] }
# MySQL (infers the key from the columns)
on_duplicate_key_update: %i[name last_name birthday]

ActiveAdmin.register Author do
 active_admin_import validate: false,
 on_duplicate_key_update: { conflict_target: [:id], columns: %i[name last_name birthday] }
end

Delete-then-insert (any database)

ActiveAdmin.register Post do
 active_admin_import before_batch_import: ->(importer) {
 Post.where(id: importer.values_at('id')).delete_all
 }
end

Tune batch size

ActiveAdmin.register Post do
 active_admin_import validate: false,
 csv_options: { col_sep: ";" },
 batch_size: 1000
end

Import into an intermediate table

ActiveAdmin.register Post do
 active_admin_import validate: false,
 csv_options: { col_sep: ";" },
 resource_class: ImportedPost, # write to a staging table
 before_import: ->(_) { ImportedPost.delete_all },
 after_import: ->(_) {
 Post.transaction do
 Post.delete_all
 Post.connection.execute("INSERT INTO posts (SELECT * FROM imported_posts)")
 end
 },
 back: ->(_) { config.namespace.resource_for(Post).route_collection_path }
end

Allow user input for CSV options (custom template)

ActiveAdmin.register Post do
 active_admin_import validate: false,
 template: 'admin/posts/import',
 template_object: ActiveAdminImport::Model.new(
 hint: "you can configure CSV options",
 csv_options: { col_sep: ";", row_sep: nil, quote_char: nil }
 )
end

<p><%= raw(@active_admin_import_model.hint) %></p>
<%= semantic_form_for @active_admin_import_model, url: { action: :do_import }, html: { multipart: true } do |f| %>
 <%= f.inputs do %>
 <%= f.input :file, as: :file %>
 <% end %>
 <%= f.inputs "CSV options", for: [:csv_options, OpenStruct.new(@active_admin_import_model.csv_options)] do |csv| %>
 <% csv.with_options input_html: { style: 'width:40px;' } do |opts| %>
 <%= opts.input :col_sep %>
 <%= opts.input :row_sep %>
 <%= opts.input :quote_char %>
 <% end %>
 <% end %>
 <%= f.actions do %>
 <%= f.action :submit,
 label: t("active_admin_import.import_btn"),
 button_html: { disable_with: t("active_admin_import.import_btn_disabled") } %>
 <% end %>
<% end %>

Inspecting the importer in batch callbacks

active_admin_import before_batch_import: ->(importer) {
 importer.file # the uploaded file
 importer.resource # the ActiveRecord class being imported into
 importer.options # the resolved options hash
 importer.headers # CSV headers (mutable)
 importer.csv_lines # parsed CSV rows for the current batch (mutable)
 importer.model # the template_object instance
}

Dependencies

Contributing