Add a new Administrate page to allow and track uploads.

This commit adds new UI in /admin to allow users to upload CSVs of
schools and track the results of the upload jobs in the UI.

They can also download CSV files of the resulting school structures.

Add index, show and new views for Administrate

Add SchoolImportResultDashboard

Add routes for admin interface for school_import_results

Add SchoolImportResultsController to show results in the UI.

This commit also adds code to new.html.erb to show validation errors if
the uploaded CSV can't be enqueued as a batch.

Author: fspeirs

app/controllers/admin/school_import_results_controller.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Admin
+  class SchoolImportResultsController < Admin::ApplicationController
+    def index
+      search_term = params[:search].to_s.strip
+      resources = Administrate::Search.new(
+        SchoolImportResult.all,
+        dashboard_class,
+        search_term
+      ).run
+      resources = apply_collection_includes(resources)
+      resources = order.apply(resources)
+      resources = resources.page(params[:_page]).per(records_per_page)
+      
+      # Batch load user info to avoid N+1 queries
+      user_ids = resources.map(&:user_id).compact.uniq
+      RequestStore.store[:user_info_cache] = fetch_users_batch(user_ids)
+      
+      page = Administrate::Page::Collection.new(dashboard, order: order)
+
+      render locals: {
+        resources: resources,
+        search_term: search_term,
+        page: page,
+        show_search_bar: show_search_bar?
+      }
+    end
+
+    def show
+      respond_to do |format|
+        format.html do
+          render locals: {
+            page: Administrate::Page::Show.new(dashboard, requested_resource)
+          }
+        end
+        format.csv do
+          send_data generate_csv(requested_resource),
+                    filename: "school_import_#{requested_resource.job_id}_#{Date.current.strftime('%Y-%m-%d')}.csv",
+                    type: 'text/csv'
+        end
+      end
+    end
+
+    def new
+      @error_details = flash[:error_details]
+      render locals: {
+        page: Administrate::Page::Form.new(dashboard, SchoolImportResult.new)
+      }
+    end
+
+    def create
+      if params[:csv_file].blank?
+        flash[:error] = 'CSV file is required'
+        redirect_to new_admin_school_import_result_path
+        return
+      end
+
+      # Call the same service that the API endpoint uses, ensuring all validation is applied
+      result = School::ImportBatch.call(
+        csv_file: params[:csv_file],
+        current_user: current_user
+      )
+
+      if result.success?
+        flash[:notice] = "Import job started successfully. Job ID: #{result[:job_id]}"
+        redirect_to admin_school_import_results_path
+      else
+        # Display error inline on the page
+        flash.now[:error] = format_error_message(result[:error])
+        @error_details = extract_error_details(result[:error])
+        render :new, locals: {
+          page: Administrate::Page::Form.new(dashboard, SchoolImportResult.new)
+        }
+      end
+    end
+
+    private
+
+    def default_sorting_attribute
+      :created_at
+    end
+
+    def default_sorting_direction
+      :desc
+    end
+
+    def format_error_message(error)
+      return error.to_s unless error.is_a?(Hash)
+
+      error[:message] || error['message'] || 'Import failed'
+    end
+    
+    def extract_error_details(error)
+      return nil unless error.is_a?(Hash)
+      
+      error[:details] || error['details']
+    end
+
+    def generate_csv(import_result)
+
+      CSV.generate(headers: true) do |csv|
+        # Header row
+        csv << ['Status', 'School Name', 'School Code', 'School ID', 'Owner Email', 'Error Code', 'Error Message']
+
+        results = import_result.results
+        successful = results['successful'] || []
+        failed = results['failed'] || []
+
+        # Successful schools
+        successful.each do |school|
+          csv << [
+            'Success',
+            school['name'],
+            school['code'],
+            school['id'],
+            school['owner_email'],
+            '',
+            ''
+          ]
+        end
+
+        # Failed schools
+        failed.each do |school|
+          csv << [
+            'Failed',
+            school['name'],
+            '',
+            '',
+            school['owner_email'],
+            school['error_code'],
+            school['error']
+          ]
+        end
+      end
+    end
+    
+    def fetch_users_batch(user_ids)
+      return {} if user_ids.empty?
+      
+      users = UserInfoApiClient.fetch_by_ids(user_ids)
+      users.each_with_object({}) do |user, hash|
+        hash[user[:id]] = user
+      end
+    rescue StandardError => e
+      Rails.logger.error("Failed to batch fetch user info: #{e.message}")
+      {}
+    end
+  end
+end

app/dashboards/school_import_result_dashboard.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'administrate/base_dashboard'
+
+class SchoolImportResultDashboard < Administrate::BaseDashboard
+  ATTRIBUTE_TYPES = {
+    id: Field::String,
+    job_id: StatusField,
+    user_id: UserInfoField,
+    results: ResultsSummaryField,
+    created_at: Field::DateTime,
+    updated_at: Field::DateTime
+  }.freeze
+
+  COLLECTION_ATTRIBUTES = %i[
+    job_id
+    user_id
+    results
+    created_at
+  ].freeze
+
+  SHOW_PAGE_ATTRIBUTES = %i[
+    id
+    job_id
+    user_id
+    results
+    created_at
+    updated_at
+  ].freeze
+
+  FORM_ATTRIBUTES = [].freeze
+
+  COLLECTION_FILTERS = {}.freeze
+
+  def display_resource(school_import_result)
+    "Import Job #{school_import_result.job_id}"
+  end
+end

app/fields/results_summary_field.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'administrate/field/base'
+
+class ResultsSummaryField < Administrate::Field::Base
+  def to_s
+    "#{successful_count} successful, #{failed_count} failed"
+  end
+
+  def successful_count
+    data.dig('successful')&.count || 0
+  end
+
+  def failed_count
+    data.dig('failed')&.count || 0
+  end
+
+  def total_count
+    successful_count + failed_count
+  end
+end

app/fields/status_field.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'administrate/field/base'
+
+class StatusField < Administrate::Field::Base
+  def to_s
+    job_status
+  end
+
+  def job_status
+    return 'unknown' if data.blank?
+
+    job = GoodJob::Execution.find_by(active_job_id: data)
+    return 'not_found' unless job
+
+    return 'failed' if job.error.present?
+    return 'completed' if job.finished_at.present?
+    return 'scheduled' if job.scheduled_at.present? && job.scheduled_at > Time.current
+    return 'running' if job.performed_at.present? && job.finished_at.nil?
+
+    'queued'
+  end
+
+  def status_class
+    case job_status
+    when 'completed' then 'status-completed'
+    when 'failed' then 'status-failed'
+    when 'running' then 'status-running'
+    when 'queued', 'scheduled' then 'status-queued'
+    else 'status-unknown'
+    end
+  end
+end

app/fields/user_info_field.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'administrate/field/base'
+
+class UserInfoField < Administrate::Field::Base
+  def to_s
+    user_display
+  end
+
+  def user_display
+    return 'Unknown User' if data.blank?
+
+    user_info = fetch_user_info
+    return data if user_info.nil?
+
+    if user_info[:name].present? && user_info[:email].present?
+      "#{user_info[:name]} <#{user_info[:email]}>"
+    elsif user_info[:name].present?
+      user_info[:name]
+    elsif user_info[:email].present?
+      user_info[:email]
+    else
+      data
+    end
+  end
+
+  def user_name
+    return nil if data.blank?
+
+    user_info = fetch_user_info
+    user_info&.dig(:name)
+  end
+
+  def user_email
+    return nil if data.blank?
+
+    user_info = fetch_user_info
+    user_info&.dig(:email)
+  end
+
+  def user_id
+    data
+  end
+
+  private
+
+  def fetch_user_info
+    return @user_info if defined?(@user_info)
+
+    @user_info = begin
+      # Try to get from request-level cache first (set by controller)
+      cache = RequestStore.store[:user_info_cache] || {}
+      cached = cache[data]
+      
+      if cached
+        cached
+      else
+        # Fallback to individual API call if not in cache
+        result = UserInfoApiClient.fetch_by_ids([data])
+        result&.first
+      end
+    rescue StandardError => e
+      Rails.logger.error("Failed to fetch user info for #{data}: #{e.message}")
+      nil
+    end
+  end
+end

app/views/admin/school_import_results/index.html.erb

@@ -0,0 +1,43 @@
+<%#
+# Index
+
+This view is the template for the index page.
+It renders the search bar, header and pagination.
+It renders the `_table` partial to display details about the resources.
+
+## Local variables:
+
+- `resources`:
+  An ActiveModel::Relation collection of resources to be displayed in the table.
+  By default, the number of resources is limited by pagination
+  or by a hard limit to prevent excessive page load times
+%>
+
+<% content_for(:title) { "School Import History" } %>
+
+<header class="main-content__header">
+  <h1 class="main-content__page-title">
+    <%= content_for(:title) %>
+  </h1>
+
+  <div>
+    <%= link_to(
+      "New Import",
+      new_admin_school_import_result_path,
+      class: "button button--primary",
+    ) %>
+  </div>
+</header>
+
+<section class="main-content__body main-content__body--flush">
+  <%= render(
+    "collection",
+    collection_presenter: page,
+    collection_field_name: :resources,
+    page: page,
+    resources: resources,
+    table_title: "page_title"
+  ) %>
+
+  <%= paginate resources, param_name: :_page %>
+</section>