ixport 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81097e7e2778b75a3e0a8e036151b7cc6627c50bd929f86129a78c429083cb38
-  data.tar.gz: 5d16aede3fdae08b99f79afe2db7933b5b171ee92efa6c4998224269a5742191
+  metadata.gz: 48f9af7983bb1c63e4df9cf1c02681f6a0aba4f40a7bf86fe7cfbfe072cf82d2
+  data.tar.gz: 816d85ef4796bc08057d087d8ef67c96366a2d3f3726680be4b645479fbdc703
 SHA512:
-  metadata.gz: d874135a600df60b6c2c98a56d41160d171a132eada93fad35de5494792afc256fc63132a905e57577653025b0b2b69404548d9fd6024613e55057a6f752126d
-  data.tar.gz: a690f23002ff143c8bc1a2906b213df52f358e6e40d6405e3a7686906de653d1d8af5d90441ff3d11b2b62c79337a367acdaba46a8ec487abeeebdf4d702b419
+  metadata.gz: 9592b85531796f33f18e3610de6574ff1530d64cc8b692161e54621589a2ef52ed1e80e40ace9622522bd402e96548e710e16e18db35ab1b018a30d56d972171
+  data.tar.gz: 744e6ff530c9a5b1b79bdcdc8f6fb3388c4c8f329948b90f5cddea19bf0c40a85db7a3c10caa8653719326878b67ee32711f92b35b7d43c15300dd4e6aca755a

data/README.md

@@ -1,10 +1,10 @@
 # ixport
 
-CSV import and export for Rails apps. An app registers the kinds of CSV a person can import and the fields each one maps to.
+CSV import and export for Rails apps. An app registers the kinds of CSV a person can import and the fields each one maps to, and the CSV downloads a person can export.
 
 ## Installation
 
-Add the gem and run its install generator, which copies the migrations for its imports table and the table of rows an import refused:
+Add the gem and run its install generator, which copies the migrations for its tables:
 
 ```ruby
 gem "ixport"
@@ -16,6 +16,13 @@ bin/rails generate ixport:install
 bin/rails db:migrate
 ```
 
+After updating the gem, run its update generator to copy any migrations added since it was installed, then migrate:
+
+```bash
+bin/rails generate ixport:update
+bin/rails db:migrate
+```
+
 Mount the engine at the path its pages should live under:
 
 ```ruby
@@ -33,6 +40,7 @@ Ixport.configure do |config|
   config.current_account_method = :current_account   # returns the account an import belongs to
   config.layout = "application"                      # the layout ixport's pages are drawn in
   config.inline_row_limit = 1_000                    # the most rows an import may have when it runs inside the request
+  config.background_runner = nil                     # :wallflower, or the name of the app's own runner class
 end
 ```
 
@@ -66,7 +74,7 @@ Each field's key is the record's attribute name. ixport looks up every match val
 
 ## Uploading and mapping a file
 
-From the engine's root page, a person picks a registered import and uploads a CSV for it. The upload is refused, with a message on the upload page, when the file has no header row or has more rows than `config.inline_row_limit`.
+From the engine's root page, a person picks a registered import and uploads a CSV for it. The upload is refused, with a message on the upload page, when the file is not UTF-8 text, when its quoting is broken (the message names the line where reading stopped), when it has no header row, or, in an app with no background runner, when it has more rows than `config.inline_row_limit`. A byte order mark at the start of the file is ignored, so the first column keeps its name.
 
 After uploading, the person matches each column of the file's header row to one of the importer's fields, by its label, or skips it. Saving the mapping moves them on to the preview.
 
@@ -74,12 +82,85 @@ The preview shows how many rows will add a record, update one or be refused, bef
 
 ## Running an import
 
-The person runs the import from the preview, and it runs inside the request. Each row that passes the record's validations is saved, updating the record it matches or adding a new one. Each row that fails them is refused and kept with its row number and reason, and the record it matched is left unchanged.
+The person runs the import from the preview. With no background runner configured, it runs inside the request. Each row that passes the record's validations is saved, updating the record it matches or adding a new one. Each row that fails them is refused and kept with its row number and reason, and the record it matched is left unchanged.
 
 The import's result page then shows how many rows were added and how many updated, and lists each refused row. It shows the same thing on every later visit. A finished import offers no Run button, its preview leads to its result page, and running it again adds or changes nothing.
 
 An import belongs to the person and account that uploaded it, and anyone else gets not found when they open it.
 
+An import whose run raises an error stops there and is marked failed. Its page shows the error's message and how many rows were added and updated before it stopped, and those rows stay saved. The error is reported through `Rails.error`. Through wallflower, the task fails with the same message and still links to the import's page.
+
+The engine's root page also lists the person's imports in the current account, newest first. Each shows its title, file name, status and date, and its added, updated and refused counts once it has run. Each opens the page for the step the import has reached: its mapping, its preview, or its result.
+
+## Running imports in the background
+
+With `config.background_runner` set, every import runs through the runner, whatever its size, and the inline row limit does not apply. Having wallflower loaded does not set it.
+
+Set it to `:wallflower` to run imports as wallflower tasks. Running an import then starts a task and takes the person to the task page, which shows its progress, the rows it changed and refused, and a link to the import's result page when it finishes. The host must mount wallflower under its own name. Run `bin/rails generate ixport:update` after updating, for the migration that links an import to its task.
+
+Set it to the name of the app's own runner class to run imports another way. ixport hands each import to the class's `enqueue`, and the runner later runs it with `Ixport.run_import`. Until then the import's page shows it as running:
+
+```ruby
+class ImportRunner
+  def self.enqueue(import)
+    RunImportJob.perform_later(import.id)
+  end
+end
+
+class RunImportJob < ApplicationJob
+  def perform(import_id)
+    Ixport.run_import(Ixport::Import.find(import_id))
+  end
+end
+```
+
+## Fixed exports
+
+A fixed export is a CSV download whose columns the app chooses. Register each one in an initializer with its key, its title and the name of its exporter class:
+
+```ruby
+Ixport.register_export :products, title: "Products", exporter: "ProductExporter"
+```
+
+An app whose registered exporter class does not exist fails to boot, with a message naming the class.
+
+An exporter lists its columns, each with the label that heads it in the CSV. A column can come from a related record by naming the association it comes through. `records` returns the records to export, reached through the `person` and `account` the download is for:
+
+```ruby
+class ProductExporter < Ixport::Exporter
+  column :sku, label: "SKU"
+  column :price_cents, label: "Price"
+  column :name, label: "Category", through: :category
+
+  def records
+    account.products.includes(:category)
+  end
+end
+```
+
+The engine's exports page, at `exports` under the mount path, lists every registered export by its title, each linking to its download. The download's header row is the exporter's column labels in order, followed by one row per record.
+
+## Chosen exports and templates
+
+An export registered with `chosen: true` lets a person pick its columns instead of taking all of them. It uses the same kind of exporter:
+
+```ruby
+Ixport.register_export :products, title: "Products", exporter: "ProductExporter", chosen: true
+```
+
+On the exports page, a chosen export lists its saved templates and offers New template. A template has a name and the exporter's columns picked in order, and downloading it gives a CSV of only those columns. Every member of an account sees, downloads, edits and deletes the account's templates, and another account's templates answer not found. A template whose column the exporter no longer lists still downloads, without that column.
+
+## Who may import or export
+
+Any import or export registration can take an `allow:` rule. It receives the signed-in person and the current account, and returns true to allow them. A rule can call the app's own Pundit policy:
+
+```ruby
+Ixport.register_import :products, title: "Products", importer: "ProductImporter",
+  allow: ->(person, account) { ProductImportPolicy.new(person, account).create? }
+```
+
+A person the rule refuses does not see that import or export listed, nor their past imports of it, and every one of its pages and downloads answers not found. A registration with no rule is open to every signed-in person.
+
 ## Claude Code agents
 
 ixport ships its own Claude Code agents through [the_local](https://github.com/DYB-Development/the_local). An app that lists ixport in its Gemfile and runs `bundle exec the_local install` gets them in `.claude/agents/`.

data/app/controllers/ixport/application_controller.rb

@@ -7,9 +7,13 @@ module Ixport
 
     private
 
+    def allowed?(registration)
+      registration.allows?(ixport_person, ixport_account)
+    end
+
     def find_import
       @import = Import.find_by(id: params[:import_id] || params[:id], person: ixport_person, account: ixport_account)
-      head :not_found unless @import
+      head :not_found unless @import && allowed?(Ixport.registration(@import.key))
     end
 
     def ixport_person

data/app/controllers/ixport/export_templates_controller.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Ixport
+  class ExportTemplatesController < ApplicationController
+    before_action :find_chosen_export, only: %i[new create]
+    before_action :find_template, only: %i[show edit update destroy]
+
+    def new
+      @columns = @registration.exporter.constantize.columns
+    end
+
+    def create
+      ExportTemplate.create!(key: @registration.key, name: params[:name], columns: known_columns(@registration), person: ixport_person, account: ixport_account)
+      redirect_to exports_path
+    end
+
+    def show
+      exporter = @template.registration.exporter.constantize.new(person: ixport_person, account: ixport_account)
+      send_data CsvWriter.new(exporter, @template.picked_columns).to_csv, filename: "#{@template.name.parameterize}.csv", type: "text/csv"
+    end
+
+    def edit
+      @columns = @template.registration.exporter.constantize.columns
+    end
+
+    def update
+      @template.update!(name: params[:name], columns: known_columns(@template.registration))
+      redirect_to exports_path
+    end
+
+    def destroy
+      @template.destroy!
+      redirect_to exports_path
+    end
+
+    private
+
+    def find_template
+      @template = ExportTemplate.find_by(id: params[:id], account: ixport_account)
+      head :not_found unless @template && allowed?(@template.registration)
+    end
+
+    def find_chosen_export
+      @registration = Ixport.export_registrations[params[:export_id].to_s.to_sym]
+      head :not_found unless @registration&.chosen && allowed?(@registration)
+    end
+
+    def known_columns(registration)
+      Array(params[:columns]).compact_blank & registration.exporter.constantize.columns.map { |column| column.key.to_s }
+    end
+  end
+end

data/app/controllers/ixport/exports_controller.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Ixport
+  class ExportsController < ApplicationController
+    def index
+      @registrations = Ixport.export_registrations.values.select { |registration| allowed?(registration) }
+      @templates = ExportTemplate.where(account: ixport_account).order(:name).group_by(&:key)
+    end
+
+    def show
+      registration = Ixport.export_registrations[params[:id].to_sym]
+      return head :not_found unless registration && allowed?(registration)
+
+      exporter = registration.exporter.constantize.new(person: ixport_person, account: ixport_account)
+      send_data CsvWriter.new(exporter).to_csv, filename: "#{registration.key}.csv", type: "text/csv"
+    end
+  end
+end

data/app/controllers/ixport/imports_controller.rb

@@ -6,14 +6,15 @@ module Ixport
     before_action :find_import, only: :show
 
     def index
-      @registrations = Ixport.registrations.values
+      @registrations = Ixport.registrations.values.select { |registration| allowed?(registration) }
+      @imports = Import.where(person: ixport_person, account: ixport_account, key: @registrations.map { |registration| registration.key.to_s }).order(created_at: :desc).with_attached_file.includes(:refusals)
     end
 
     def new
     end
 
     def show
-      redirect_to import_preview_path(@import) unless @import.finished?
+      redirect_to import_preview_path(@import) if @import.status == "pending"
     end
 
     def create
@@ -30,7 +31,7 @@ module Ixport
 
     def find_registration
       @registration = Ixport.registrations[params[:key].to_s.to_sym]
-      head :not_found unless @registration
+      head :not_found unless @registration && allowed?(@registration)
     end
   end
 end

data/app/controllers/ixport/previews_controller.rb

@@ -5,9 +5,9 @@ module Ixport
     before_action :find_import
 
     def show
-      return redirect_to import_path(@import) if @import.finished?
+      return redirect_to import_path(@import) unless @import.status == "pending"
 
-      rows = RowWalk.new(@import, @import.importer_class.new(person: ixport_person, account: ixport_account)).rows
+      rows = @import.rows
       @counts = { add: 0, update: 0, refused: 0 }.merge(rows.group_by(&:outcome).transform_values(&:size))
       @update_rows = rows.select { |row| row.outcome == :update }
       @refused_rows = rows.select { |row| row.outcome == :refused }

data/app/controllers/ixport/runs_controller.rb

@@ -5,7 +5,19 @@ module Ixport
     before_action :find_import
 
     def create
-      @import.run!(@import.importer_class.new(person: ixport_person, account: ixport_account))
+      runner = Ixport.background_runner
+      return run_in_request unless runner
+      return redirect_to import_path(@import) unless @import.status == "pending"
+
+      @import.update!(status: "running")
+      runner.enqueue(@import)
+      redirect_to @import.wallflower_task_id ? wallflower.task_path(@import.wallflower_task_id) : import_path(@import)
+    end
+
+    private
+
+    def run_in_request
+      @import.run!
       redirect_to import_path(@import)
     end
   end

data/app/helpers/ixport/imports_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Ixport
+  module ImportsHelper
+    def import_step_path(import)
+      case import.step
+      when :result then import_path(import)
+      when :preview then import_preview_path(import)
+      else import_mapping_path(import)
+      end
+    end
+  end
+end

data/app/models/ixport/csv_writer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Ixport
+  class CsvWriter
+    def initialize(exporter, columns = exporter.class.columns)
+      @exporter = exporter
+      @columns = columns
+    end
+
+    def to_csv
+      CSV.generate do |csv|
+        csv << @columns.map(&:label)
+        @exporter.records.each { |record| csv << @columns.map { |column| @exporter.value(record, column) } }
+      end
+    end
+  end
+end

data/app/models/ixport/export_template.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ixport
+  class ExportTemplate < ApplicationRecord
+    self.table_name = "ixport_export_templates"
+
+    belongs_to :person, polymorphic: true
+    belongs_to :account, polymorphic: true, optional: true
+
+    def registration
+      Ixport.export_registration(key)
+    end
+
+    def picked_columns
+      exporter_columns = registration.exporter.constantize.columns.index_by { |column| column.key.to_s }
+      columns.filter_map { |key| exporter_columns[key] }
+    end
+  end
+end

data/app/models/ixport/import.rb

@@ -12,12 +12,11 @@ module Ixport
     has_one_attached :file
     has_many :refusals, -> { order(:row_number) }, class_name: "Ixport::ImportRefusal", dependent: :destroy
 
-    validate :file_has_header_row, on: :create
-    validate :file_within_inline_row_limit, on: :create
+    validate :incoming_file_is_usable, on: :create
 
-    def run!(importer)
+    def run!(reporter: NullReporter.new)
       with_lock do
-        walk_and_save(importer) unless finished?
+        walk_and_save(reporter) if status.in?(%w[pending running])
       end
     end
 
@@ -25,36 +24,89 @@ module Ixport
       status == "finished"
     end
 
+    def running?
+      status == "running"
+    end
+
+    def failed?
+      status == "failed"
+    end
+
+    def step
+      return :result if finished?
+
+      mapping.present? ? :preview : :mapping
+    end
+
+    def title
+      Ixport.registration(key).title
+    end
+
+    def rows
+      RowWalk.new(self, importer).rows
+    end
+
+    def importer
+      importer_class.new(person: person, account: account)
+    end
+
     def importer_class
       Ixport.registration(key).importer.constantize
     end
 
     def headers
-      CSV.parse_line(file.download) || []
+      CSV.parse_line(contents) || []
+    end
+
+    def contents
+      self.class.readable(file.download)
+    end
+
+    def self.readable(text)
+      text.to_s.dup.force_encoding(Encoding::UTF_8).delete_prefix("\uFEFF")
     end
 
     private
 
-    def walk_and_save(importer)
-      rows = RowWalk.new(self, importer).rows
+    def walk_and_save(reporter)
+      counts = { add: 0, update: 0 }
+      rows = self.rows
+      reporter.set_total(rows.size)
       rows.each do |row|
-        if row.outcome == :refused
-          refusals.create!(row_number: row.number, reason: row.reason)
-        else
-          row.record.save!
-        end
+        save_row(row, reporter)
+        counts[row.outcome] += 1 if counts.key?(row.outcome)
+        reporter.advance
       end
-      update!(status: "finished", added_count: rows.count { |row| row.outcome == :add }, updated_count: rows.count { |row| row.outcome == :update })
+      update!(status: "finished", added_count: counts[:add], updated_count: counts[:update])
+    rescue StandardError => error
+      Rails.error.report(error)
+      update!(status: "failed", error_message: error.message, added_count: counts[:add], updated_count: counts[:update])
     end
 
-    def file_has_header_row
-      errors.add(:file, "This file has no header row.") if CSV.parse_line(incoming_file_contents).blank?
+    def save_row(row, reporter)
+      if row.outcome == :refused
+        refusals.create!(row_number: row.number, reason: row.reason)
+        reporter.refuse(label: "Row #{row.number}", reason: row.reason)
+      else
+        self.class.transaction(requires_new: true) { row.record.save! }
+      end
+    end
+
+    def incoming_file_is_usable
+      text = incoming_file_contents
+      return errors.add(:file, "This file is not UTF-8 text. Save it as UTF-8 and upload it again.") unless text.valid_encoding?
+
+      rows = CSV.parse(text)
+      return errors.add(:file, "This file has no header row.") if rows.first.blank?
+
+      check_inline_row_limit(rows.size - 1) unless Ixport.configuration.background_runner
+    rescue CSV::MalformedCSVError => error
+      errors.add(:file, "This file could not be read past line #{error.line_number}. Check the quotes on that line.")
     end
 
-    def file_within_inline_row_limit
+    def check_inline_row_limit(row_count)
       limit = Ixport.configuration.inline_row_limit
-      rows = [ CSV.parse(incoming_file_contents).size - 1, 0 ].max
-      errors.add(:file, "This file has #{rows} rows, and the most an import can have is #{limit}.") if rows > limit
+      errors.add(:file, "This file has #{row_count} rows, and the most an import can have is #{limit}.") if row_count > limit
     end
 
     def incoming_file_contents
@@ -62,7 +114,7 @@ module Ixport
       io = attachable.is_a?(Hash) ? attachable[:io] : attachable
       return "" unless io
 
-      io.read.tap { io.rewind }.to_s
+      self.class.readable(io.read.tap { io.rewind })
     end
   end
 end

data/app/models/ixport/null_reporter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Ixport
+  class NullReporter
+    def set_total(_total); end
+
+    def advance; end
+
+    def refuse(label:, reason:); end
+  end
+end

data/app/models/ixport/row_walk.rb

@@ -27,7 +27,7 @@ module Ixport
     end
 
     def data_rows
-      @data_rows ||= CSV.parse(@import.file.download).drop(1)
+      @data_rows ||= CSV.parse(@import.contents).drop(1)
     end
 
     def values_of(cells)

data/app/models/ixport/wallflower_runner.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Ixport
+  class WallflowerRunner
+    def self.enqueue(import)
+      task = Wallflower.start(kind: :ixport_import, person: import.person, account: import.account, params: { "import_id" => import.id })
+      import.update!(wallflower_task_id: task.id)
+    end
+  end
+end

data/app/models/ixport/wallflower_task_runner.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ixport
+  class WallflowerTaskRunner
+    include Rails.application.routes.mounted_helpers
+
+    def call(task)
+      import = Import.find(task.params["import_id"])
+      Ixport.run_import(import, reporter: task)
+      task.link_result(ixport.import_path(import))
+      raise ImportFailed, import.error_message if import.failed?
+    end
+  end
+end

data/app/views/ixport/export_templates/edit.html.erb

@@ -0,0 +1,14 @@
+<%= ui_form_page(title: "Edit #{@template.name}", subtitle: @template.registration.title, back_url: exports_path) %>
+<%= ui_page(max_width: :md) do %>
+  <%= ui_form(action: export_template_path(@template), method: :patch) do %>
+    <%= ui_form_field(attribute: "name", label: "Template name", required: true, value: @template.name) %>
+    <% column_options = @columns.map { |column| [column.label, column.key] } %>
+    <% @columns.each_index do |index| %>
+      <%= ui_form_field(attribute: "columns[]", label: "Column #{index + 1}", type: :select, options: column_options, include_blank: "None", value: @template.columns[index]) %>
+    <% end %>
+    <%= ui_button(label: "Save template") %>
+  <% end %>
+  <%= ui_action_menu do %>
+    <%= ui_action_menu_item(label: "Delete", href: export_template_path(@template), method: :delete) %>
+  <% end %>
+<% end %>

data/app/views/ixport/export_templates/new.html.erb

@@ -0,0 +1,11 @@
+<%= ui_form_page(title: "New #{@registration.title} template", back_url: exports_path) %>
+<%= ui_page(max_width: :md) do %>
+  <%= ui_form(action: export_templates_path(@registration.key)) do %>
+    <%= ui_form_field(attribute: "name", label: "Template name", required: true) %>
+    <% column_options = @columns.map { |column| [column.label, column.key] } %>
+    <% @columns.each_index do |index| %>
+      <%= ui_form_field(attribute: "columns[]", label: "Column #{index + 1}", type: :select, options: column_options, include_blank: "None") %>
+    <% end %>
+    <%= ui_button(label: "Save template") %>
+  <% end %>
+<% end %>

data/app/views/ixport/exports/index.html.erb

@@ -0,0 +1,23 @@
+<%= ui_page(max_width: :md) do %>
+  <h1>Exports</h1>
+  <% if @registrations.empty? %>
+    <%= ui_alert(message: "No exports are set up yet.") %>
+  <% else %>
+    <% @registrations.each do |registration| %>
+      <% if registration.chosen %>
+        <div data-export><%= registration.title %></div>
+        <ul>
+          <% Array(@templates[registration.key.to_s]).each do |template| %>
+            <li>
+              <span data-export-template><%= link_to template.name, export_template_path(template) %></span>
+              <%= link_to "Edit", edit_export_template_path(template) %>
+            </li>
+          <% end %>
+        </ul>
+        <%= ui_button(label: "New template", href: new_export_template_path(registration.key), variant: :secondary, size: :sm) %>
+      <% else %>
+        <div data-export><%= link_to registration.title, export_path(registration.key) %></div>
+      <% end %>
+    <% end %>
+  <% end %>
+<% end %>

data/app/views/ixport/imports/index.html.erb

@@ -7,4 +7,21 @@
       <div data-import><%= link_to registration.title, new_import_path(key: registration.key) %></div>
     <% end %>
   <% end %>
+  <% if @imports.any? %>
+    <%= ui_section(title: "Your imports") do %>
+      <% @imports.each do |import| %>
+        <div data-past-import>
+          <%= link_to import_step_path(import), data: { step_link: true } do %><span data-import-title><%= import.title %></span><% end %>
+          <span data-file-name><%= import.file.filename.to_s %></span>
+          <span data-status><%= import.status.capitalize %></span>
+          <span data-made-on><%= import.created_at.strftime("%b %-d, %Y") %></span>
+          <% if import.finished? %>
+            <span>Added <span data-added><%= import.added_count %></span></span>
+            <span>Updated <span data-updated><%= import.updated_count %></span></span>
+            <span>Refused <span data-refused><%= import.refusals.size %></span></span>
+          <% end %>
+        </div>
+      <% end %>
+    <% end %>
+  <% end %>
 <% end %>

data/app/views/ixport/imports/show.html.erb

@@ -1,20 +1,35 @@
-<%= ui_show_page(title: "Import finished", back_url: root_path) %>
+<% heading = if @import.running?
+                "Import running"
+              elsif @import.failed?
+                "Import failed"
+              else
+                "Import finished"
+              end %>
+<%= ui_show_page(title: heading, back_url: root_path) %>
 <%= ui_page(max_width: :md) do %>
-  <%= ui_page_header(title: "Import finished") %>
-  <%= ui_grid(cols: { default: 1, sm: 2 }) do %>
-    <%= ui_stat_card(label: "Added", value: tag.span(@import.added_count, data: { result_count: "added" })) %>
-    <%= ui_stat_card(label: "Updated", value: tag.span(@import.updated_count, data: { result_count: "updated" })) %>
-  <% end %>
-  <% if @import.refusals.any? %>
-    <%= ui_section(title: "Refused") do %>
-      <ul>
-        <% @import.refusals.each do |refusal| %>
-          <%= tag.li(data: { refused_row: true }) do %>
-            Row <%= tag.span(refusal.row_number, data: { row_number: true }) %>
-            <%= tag.span(refusal.reason, data: { reason: true }) %>
+  <%= ui_page_header(title: heading) %>
+  <% if @import.running? %>
+    <%= ui_alert(type: :info, message: tag.span("This import is running.", data: { import_running: true })) %>
+  <% else %>
+    <% if @import.failed? %>
+      <%= ui_alert(type: :error, message: tag.span(@import.error_message, data: { import_error: true })) %>
+      <p>Rows saved before it stopped stay saved.</p>
+    <% end %>
+    <%= ui_grid(cols: { default: 1, sm: 2 }) do %>
+      <%= ui_stat_card(label: "Added", value: tag.span(@import.added_count, data: { result_count: "added" })) %>
+      <%= ui_stat_card(label: "Updated", value: tag.span(@import.updated_count, data: { result_count: "updated" })) %>
+    <% end %>
+    <% if @import.refusals.any? %>
+      <%= ui_section(title: "Refused") do %>
+        <ul>
+          <% @import.refusals.each do |refusal| %>
+            <%= tag.li(data: { refused_row: true }) do %>
+              Row <%= tag.span(refusal.row_number, data: { row_number: true }) %>
+              <%= tag.span(refusal.reason, data: { reason: true }) %>
+            <% end %>
           <% end %>
-        <% end %>
-      </ul>
+        </ul>
+      <% end %>
     <% end %>
   <% end %>
 <% end %>