ixport 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81097e7e2778b75a3e0a8e036151b7cc6627c50bd929f86129a78c429083cb38
-  data.tar.gz: 5d16aede3fdae08b99f79afe2db7933b5b171ee92efa6c4998224269a5742191
+  metadata.gz: 571077183f90149d06c934dbfc5de2eedeaa972747a6449911af9f823a073d53
+  data.tar.gz: 98a736581d838a51b59111457fcf37a5f428ff7a918ac97bb985a49a73b4f039
 SHA512:
-  metadata.gz: d874135a600df60b6c2c98a56d41160d171a132eada93fad35de5494792afc256fc63132a905e57577653025b0b2b69404548d9fd6024613e55057a6f752126d
-  data.tar.gz: a690f23002ff143c8bc1a2906b213df52f358e6e40d6405e3a7686906de653d1d8af5d90441ff3d11b2b62c79337a367acdaba46a8ec487abeeebdf4d702b419
+  metadata.gz: d36d12873d7e4daefa43065e7778fa839e71507ba9cb93d34065b8754382cf1a73b153893770cfa2d4e2caf7bc9053e36959be40f387095e6d5cfe1bc4f6aecc
+  data.tar.gz: 3ed3b12877932c4229294da54a59050dee026b887cb754e6072506e443b619265967da83b18d84ed889699a422aa782d4b278ebe8d13aacd47f01deb63e9218b

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,9 +40,13 @@ 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
+  config.base_controller = "::ApplicationController" # the controller ixport's pages inherit, with its checks and helpers
 end
 ```
 
+`config.base_controller` is read when ixport's controllers load, so set it in an initializer. Name a controller such as an admin area's base controller to give ixport's pages that area's access checks.
+
 ## Mapped imports and importers
 
 A mapped import is a kind of CSV a person can import into one of the app's records. Register each one in an initializer with its key, its title and the name of its importer class:
@@ -48,7 +59,7 @@ An app whose registered importer class does not exist fails to boot, with a mess
 
 The engine's root page lists every registered import by its title, each linking to its upload page.
 
-An importer lists the fields a person maps the file's columns to, each with the label the person sees. It names the one field rows are matched on, and the records a row may match, which it reaches through the `person` and `account` the import is for:
+An importer lists the fields a person maps the file's columns to, each with the label the person sees. It names the field or fields rows are matched on, and the records a row may match, which it reaches through the `person` and `account` the import is for:
 
 ```ruby
 class ProductImporter < Ixport::Importer
@@ -62,11 +73,13 @@ class ProductImporter < Ixport::Importer
 end
 ```
 
-Each field's key is the record's attribute name. ixport looks up every match value in the file with one query against `records`. A row whose match value matches one of those records updates it, and a row that matches nothing adds a new record built from `records`. A row whose match value is blank, or whose file has no column mapped to the match field, always adds a record.
+Each field's key is the record's attribute name. ixport looks up every match value in the file with one query against `records`. A row whose match values equal one of those records on every match field updates it, and a row that matches nothing adds a new record built from `records`. Values are compared as the record's own types, so `12.50` in a file matches `12.5` stored on a record. A row with a blank value in any match field, or whose file has no column mapped to one, always adds a record.
+
+To match on several fields, name them all, for example `match_on :happened_on, :amount, :name`.
 
 ## 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 +87,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

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
 module Ixport
-  class ApplicationController < ::ApplicationController
+  class ApplicationController < Ixport.configuration.base_controller.constantize
     before_action { send(Ixport.configuration.authentication_method) }
     layout -> { Ixport.configuration.layout }
 
     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

@@ -19,7 +19,7 @@ module Ixport
 
     def row_for(cells, number)
       values = values_of(cells)
-      existing = existing_records[values[match_field]]
+      existing = existing_records[match_key(values)]
       record = existing ? existing.tap { |found| found.assign_attributes(values) } : @importer.records.new(values)
       return Row.new(number: number, record: record, outcome: :refused, reason: record.errors.full_messages.to_sentence) unless record.valid?
 
@@ -27,21 +27,30 @@ 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)
       @import.mapping.to_h { |column, field| [ field.to_sym, cells[column.to_i] ] }
     end
 
-    def match_field
-      @importer.class.match_field
+    def match_fields
+      @importer.class.match_fields
+    end
+
+    def match_key(values)
+      key = match_fields.map { |field| cast(field, values[field]) }
+      key unless key.any?(&:blank?)
+    end
+
+    def cast(field, value)
+      @importer.records.klass.type_for_attribute(field.to_s).cast(value)
     end
 
     def existing_records
       @existing_records ||= begin
-        match_values = data_rows.map { |cells| values_of(cells)[match_field] }.compact_blank
-        @importer.records.where(match_field => match_values).index_by { |record| record.public_send(match_field).to_s }
+        candidates = match_fields.to_h { |field| [ field, data_rows.map { |cells| cast(field, values_of(cells)[field]) }.compact_blank ] }
+        @importer.records.where(candidates).index_by { |record| match_fields.map { |field| record.public_send(field) } }
       end
     end
   end

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 %>