super_admin 0.2.0

data/app/helpers/super_admin/application_helper.rb

@@ -0,0 +1,84 @@
+module SuperAdmin
+  module ApplicationHelper
+    include SuperAdmin::Engine.routes.url_helpers
+
+    def super_admin_root_path
+      SuperAdmin::Engine.routes.url_helpers.root_path
+    end
+
+    def super_admin_exports_path
+      SuperAdmin::Engine.routes.url_helpers.exports_path
+    end
+
+    def super_admin_audit_logs_path
+      SuperAdmin::Engine.routes.url_helpers.audit_logs_path
+    end
+
+    def pagy_nav(pagy)
+      return "" unless pagy
+
+      base_params = request.query_parameters.symbolize_keys.except(:page)
+      prev_link   = pagy_page_link("Previous", pagy.page - 1, base_params) if pagy.page > 1
+      next_link   = pagy_page_link("Next", pagy.page + 1, base_params) if pagy.page < pagy.pages
+
+      content_tag(:nav, class: "pagy-simple-nav", aria: { label: "Pagination" }) do
+        safe_join([
+          prev_link || pagy_disabled_page_link("Previous"),
+          content_tag(:span, "Page #{pagy.page} of #{pagy.pages}", class: "pagy-simple-nav__info"),
+          next_link || pagy_disabled_page_link("Next")
+        ], "\n".html_safe)
+      end
+    end
+
+    def audit_action_options
+      return [] unless audit_log_ready?
+
+      SuperAdmin::AuditLog.distinct.pluck(:action).compact.sort.map do |action|
+        [ action.humanize, action ]
+      end
+    end
+
+    def audit_resource_options
+      return [] unless audit_log_ready?
+
+      SuperAdmin::AuditLog.distinct.pluck(:resource_type).compact.sort.map do |type|
+        [ type, type ]
+      end
+    end
+
+    def action_badge_class(action)
+      case action.to_s
+      when "create"
+        "bg-green-100 text-green-800"
+      when "update"
+        "bg-blue-100 text-blue-800"
+      when "destroy", "bulk_destroy"
+        "bg-red-100 text-red-800"
+      else
+        "bg-gray-100 text-gray-800"
+      end
+    end
+
+    private
+
+    def pagy_page_link(label, page, params)
+      link_to label, pagy_page_url(page, params), class: "pagy-simple-nav__link"
+    end
+
+    def pagy_disabled_page_link(label)
+      content_tag(:span, label, class: "pagy-simple-nav__link pagy-simple-nav__link--disabled", aria: { disabled: true })
+    end
+
+    def pagy_page_url(page, params)
+      query = params.merge(page: page).compact_blank
+      query_string = query.to_query
+      query_string.present? ? "#{request.path}?#{query_string}" : request.path
+    end
+
+    def audit_log_ready?
+      SuperAdmin::AuditLog.table_exists?
+    rescue ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
+      false
+    end
+  end
+end

data/app/helpers/super_admin/exports_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  module ExportsHelper
+    BADGE_CLASSES = {
+      "pending" => "bg-yellow-100 text-yellow-800",
+      "processing" => "bg-blue-100 text-blue-800",
+      "ready" => "bg-green-100 text-green-800",
+      "failed" => "bg-red-100 text-red-800"
+    }.freeze
+
+    def export_badge_classes(export)
+      BADGE_CLASSES.fetch(export.status, "bg-gray-100 text-gray-800")
+    end
+  end
+end

data/app/helpers/super_admin/resources_helper.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  # Helper for SuperAdmin views
+  module ResourcesHelper
+    # Formats attribute value for display
+    # @param resource [ActiveRecord::Base] The record
+    # @param attribute [String, Symbol] The attribute name
+    # @return [String] Formatted value
+    def format_attribute_value(resource, attribute)
+      value = resource.send(attribute)
+
+      case value
+      when nil
+        content_tag(:span, "—", class: "text-gray-400 italic")
+      when true
+        content_tag(:span, "✓", class: "text-green-600 font-bold")
+      when false
+        content_tag(:span, "✗", class: "text-red-600 font-bold")
+      when Date
+        l(value, format: :long)
+      when Time, DateTime, ActiveSupport::TimeWithZone
+        l(value, format: :long)
+      when Integer
+        number_with_delimiter(value)
+      when Float, BigDecimal
+        number_with_precision(value, precision: 2, delimiter: " ")
+      when String
+        value.present? ? value : content_tag(:span, t("super_admin.helpers.resources.empty_string"), class: "text-gray-400 italic")
+      else
+        value.to_s
+      end
+    end
+
+    # Displays the attribute value in a basic textual form used by tests and plain lists.
+    def display_attribute(resource, attribute)
+      value = resource.public_send(attribute)
+
+      return "" if value.nil?
+
+      # Handle ActiveRecord associations gracefully
+      if (reflection = resource.class.reflect_on_association(attribute))
+        return display_association_value(value, reflection)
+      end
+
+      # Enum attributes should be humanized
+      if resource.class.respond_to?(:defined_enums) && resource.class.defined_enums.key?(attribute.to_s)
+        return humanize_enum_value(resource, attribute, value)
+      end
+
+      case value
+      when TrueClass, FalseClass
+        value ? "Yes" : "No"
+      when Time, Date, DateTime, ActiveSupport::TimeWithZone
+        I18n.l(value)
+      else
+        value.to_s
+      end
+    end
+
+    # Humanizes a raw attribute name for display purposes.
+    def humanize_attribute(attribute)
+      attribute.to_s.tr("_", " ").capitalize
+    end
+
+    private
+
+    def display_association_value(value, reflection)
+      if reflection.collection?
+        value.map { |record| association_display_name(record) }.reject(&:blank?).join(", ")
+      else
+        association_display_name(value)
+      end
+    end
+
+    def association_display_name(record)
+      %i[name title email to_s].each do |method|
+        next unless record.respond_to?(method)
+
+        result = record.public_send(method)
+        return result.to_s if result.present?
+      end
+
+      ""
+    end
+
+    def humanize_enum_value(resource, attribute, value)
+      return "" if value.blank?
+
+      i18n_key = "#{attribute}.#{value}"
+      translation = resource.class.human_attribute_name(i18n_key, default: "")
+      return translation if translation.present?
+
+      value.to_s.tr("_", " ").split.map(&:capitalize).join(" ")
+    end
+
+    # Returns CSS class for status badge
+    # @param value [Object] The value to badge
+    # @return [String] CSS classes
+    def badge_class_for(value)
+      case value
+      when true
+        "bg-green-100 text-green-800"
+      when false
+        "bg-red-100 text-red-800"
+      when nil
+        "bg-gray-100 text-gray-800"
+      else
+        "bg-blue-100 text-blue-800"
+      end
+    end
+
+    # Returns icon for a column type
+    # @param column_type [Symbol] The column type
+    # @return [String] SVG icon
+    def icon_for_column_type(column_type)
+      icons = {
+        string: "M3 5h12M9 3v2m1.048 9.5A18.022 18.022 0 016.412 9m6.088 9h7M11 21l5-10 5 10M12.751 5C11.783 10.77 8.07 15.61 3 18.129",
+        text: "M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z",
+        integer: "M7 20l4-16m2 16l4-16M6 9h14M4 15h14",
+        decimal: "M9 7h6m0 10v-3m-3 3h.01M9 17h.01M9 14h.01M12 14h.01M15 11h.01M12 11h.01M9 11h.01M7 21h10a2 2 0 002-2V5a2 2 0 00-2-2H7a2 2 0 00-2 2v14a2 2 0 002 2z",
+        boolean: "M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z",
+        date: "M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z",
+        datetime: "M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z"
+      }
+
+      path = icons[column_type] || icons[:string]
+
+      content_tag(:svg, class: "h-4 w-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24") do
+        content_tag(:path, "", "stroke-linecap": "round", "stroke-linejoin": "round", "stroke-width": "2", d: path)
+      end
+    end
+
+    # Returns humanized label for a model
+    # @param model_class [Class] The model class
+    # @param count [Integer] Number for pluralization
+    # @return [String] Humanized label
+    def humanize_model_name(model_class, count: 2)
+      model_class.model_name.human(count: count)
+    end
+
+    # Generates sort options for a column
+    # @param attribute [String] The attribute name
+    # @param current_sort [String] Current sort attribute
+    # @param current_direction [String] Current sort direction
+    # @return [Hash] Parameters for sort link
+    def sort_params_for(attribute, current_sort: params[:sort], current_direction: params[:direction])
+      if current_sort == attribute
+        # Reverse direction if already sorting on this column
+        direction = current_direction == "asc" ? "desc" : "asc"
+      else
+        # Default direction
+        direction = "asc"
+      end
+
+      { sort: attribute, direction: direction }
+    end
+
+    # Returns sort indicator for a column
+    # @param attribute [String] The attribute name
+    # @param current_sort [String] Current sort attribute
+    # @param current_direction [String] Current sort direction
+    # @return [String, nil] Sort icon or nil
+    def sort_indicator_for(attribute, current_sort: params[:sort], current_direction: params[:direction])
+      return unless current_sort == attribute
+
+      if current_direction == "asc"
+        "↑"
+      else
+        "↓"
+      end
+    end
+
+    # Returns the current filter value to prefill forms
+    # @param applied_filters [Hash]
+    # @param key [String, Symbol]
+    # @return [String]
+    def filter_value(applied_filters, key)
+      return "" unless applied_filters
+
+      applied_filters[key.to_s] || applied_filters[key.to_sym] || ""
+    end
+
+    # Formats datetime value for datetime-local input field
+    def filter_datetime_value(applied_filters, key)
+      raw_value = filter_value(applied_filters, key)
+      return "" if raw_value.blank?
+
+      Time.zone.parse(raw_value.to_s).strftime("%Y-%m-%dT%H:%M")
+    rescue ArgumentError
+      raw_value
+    end
+
+    # Formats date value for date input field
+    def filter_date_value(applied_filters, key)
+      raw_value = filter_value(applied_filters, key)
+      return "" if raw_value.blank?
+
+      Date.parse(raw_value.to_s).strftime("%Y-%m-%d")
+    rescue ArgumentError
+      raw_value
+    end
+  end
+end

data/app/helpers/super_admin/route_helper.rb

@@ -0,0 +1,7 @@
+module SuperAdmin
+  module RouteHelper
+    def super_admin_engine
+      SuperAdmin::Engine.routes.url_helpers
+    end
+  end
+end

data/app/javascript/super_admin/application.js

@@ -0,0 +1,263 @@
+// SuperAdmin JavaScript entry point
+// This file auto-registers all Stimulus controllers with the host app's Stimulus instance
+
+import { Controller } from "@hotwired/stimulus"
+
+// Define controllers inline to avoid module loading issues
+class AssociationSelectController extends Controller {
+  static targets = ["select", "search", "results"]
+  static values = {
+    model: String,
+    url: String,
+    selectedId: String
+  }
+
+  connect() {
+    if (this.hasSelectTarget && this.selectTarget.dataset.searchable === "true") {
+      this.enhanceSelect()
+    }
+  }
+
+  enhanceSelect() {
+    const select = this.selectTarget
+    if (select.dataset.searchEnhanced === "true") {
+      return
+    }
+
+    const totalCount = parseInt(select.dataset.totalCount || "0")
+    const selectLimit = parseInt(select.querySelectorAll('option').length - 1) || 0
+
+    if (totalCount <= selectLimit) {
+      return
+    }
+
+    select.dataset.searchEnhanced = "true"
+    this.createSearchInterface()
+  }
+
+  createSearchInterface() {
+    const select = this.selectTarget
+    const wrapper = document.createElement("div")
+    wrapper.className = "relative"
+
+    const searchInput = document.createElement("input")
+    searchInput.type = "text"
+    searchInput.placeholder = "Rechercher..."
+    searchInput.className = "block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500 sm:text-sm px-3 py-2 mb-2"
+    searchInput.dataset.superAdminAssociationSelectTarget = "search"
+
+    let searchTimeout
+    searchInput.addEventListener("input", (e) => {
+      clearTimeout(searchTimeout)
+      searchTimeout = setTimeout(() => {
+        this.performSearch(e.target.value)
+      }, 300)
+    })
+
+    select.parentNode.insertBefore(wrapper, select)
+    wrapper.appendChild(searchInput)
+    wrapper.appendChild(select)
+  }
+
+  async performSearch(query) {
+    const select = this.selectTarget
+    const model = select.dataset.association
+    const selectedId = select.value
+
+    if (!model) {
+      console.error("Association model not defined")
+      return
+    }
+
+    try {
+      const url = new URL("/super_admin/associations/search", window.location.origin)
+      url.searchParams.set("model", model)
+      url.searchParams.set("q", query)
+      url.searchParams.set("page", "1")
+      if (selectedId) {
+        url.searchParams.set("selected_id", selectedId)
+      }
+
+      const response = await fetch(url)
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`)
+      }
+
+      const data = await response.json()
+      this.updateSelectOptions(data.results, selectedId)
+    } catch (error) {
+      console.error("Association search failed:", error)
+    }
+  }
+
+  updateSelectOptions(results, selectedId) {
+    const select = this.selectTarget
+    const hasBlank = select.querySelector('option[value=""]')
+
+    select.innerHTML = ""
+    if (hasBlank) {
+      const blankOption = document.createElement("option")
+      blankOption.value = ""
+      blankOption.textContent = ""
+      select.appendChild(blankOption)
+    }
+
+    results.forEach(result => {
+      const option = document.createElement("option")
+      option.value = result.id
+      option.textContent = result.text
+      if (result.id.toString() === selectedId) {
+        option.selected = true
+      }
+      select.appendChild(option)
+    })
+  }
+}
+
+class BulkSelectionController extends Controller {
+  static targets = ["checkbox", "toggle", "counter"]
+
+  connect() {
+    this.updateCounter()
+  }
+
+  toggleAll(event) {
+    const checked = event.target.checked
+    this.checkboxTargets.forEach((checkbox) => {
+      checkbox.checked = checked
+    })
+    if (this.hasToggleTarget) {
+      this.toggleTarget.indeterminate = false
+    }
+    this.updateCounter()
+  }
+
+  itemChanged() {
+    const allChecked = this.checkboxTargets.length > 0 && this.checkboxTargets.every((checkbox) => checkbox.checked)
+    if (this.hasToggleTarget) {
+      this.toggleTarget.indeterminate = !allChecked && this.checkboxTargets.some((checkbox) => checkbox.checked)
+      this.toggleTarget.checked = allChecked
+    }
+    this.updateCounter()
+  }
+
+  updateCounter() {
+    if (!this.hasCounterTarget) return
+
+    const selected = this.checkboxTargets.filter((checkbox) => checkbox.checked).length
+    this.counterTarget.textContent = selected
+  }
+}
+
+class NestedFormController extends Controller {
+  static targets = ["entries", "template"]
+
+  add(event) {
+    event.preventDefault()
+    if (!this.hasTemplateTarget) return
+
+    const timestamp = Date.now().toString()
+    const content = this.templateTarget.innerHTML.replace(/__NEW_RECORD__/g, timestamp)
+    this.entriesTarget.insertAdjacentHTML("beforeend", content)
+  }
+
+  remove(event) {
+    event.preventDefault()
+    const button = event.target.closest("[data-super-admin--nested-form-remove]") || event.target
+    const wrapper = button.closest("[data-super-admin--nested-form-entry]")
+    if (!wrapper) return
+
+    const destroyInput = wrapper.querySelector("input[name$='[_destroy]']")
+    const idInput = wrapper.querySelector("input[name$='[id]']")
+
+    if (destroyInput) {
+      destroyInput.value = "1"
+    }
+
+    if (idInput && idInput.value !== "") {
+      wrapper.classList.add("hidden")
+    } else {
+      wrapper.remove()
+    }
+  }
+}
+
+class FlashController extends Controller {
+  static values = {
+    autoDismiss: { type: Number, default: 5000 }
+  }
+
+  connect() {
+    if (this.autoDismissValue > 0) {
+      this.timeout = setTimeout(() => {
+        this.close()
+      }, this.autoDismissValue)
+    }
+  }
+
+  disconnect() {
+    if (this.timeout) {
+      clearTimeout(this.timeout)
+    }
+  }
+
+  close() {
+    // Use inline style for fade out animation
+    this.element.style.transition = 'opacity 0.3s ease-out, transform 0.3s ease-out'
+    this.element.style.opacity = '0'
+    this.element.style.transform = 'translateY(-10px)'
+
+    setTimeout(() => {
+      this.element.remove()
+    }, 300)
+  }
+
+  remove() {
+    this.element.remove()
+  }
+}
+
+class MobileMenuController extends Controller {
+  static targets = ["sidebar", "overlay"]
+
+  toggle() {
+    if (this.hasSidebarTarget && this.hasOverlayTarget) {
+      this.sidebarTarget.classList.toggle('-translate-x-full')
+      this.overlayTarget.classList.toggle('hidden')
+    }
+  }
+
+  close(event) {
+    // Close on overlay click or escape key
+    if (event.type === 'click' || (event.type === 'keydown' && event.key === 'Escape')) {
+      if (this.hasSidebarTarget && this.hasOverlayTarget) {
+        if (!this.overlayTarget.classList.contains('hidden')) {
+          this.toggle()
+        }
+      }
+    }
+  }
+}
+
+// Auto-register with the host app's Stimulus application
+function registerControllers() {
+  if (window.Stimulus) {
+    window.Stimulus.register("super-admin--association-select", AssociationSelectController)
+    window.Stimulus.register("super-admin--bulk-selection", BulkSelectionController)
+    window.Stimulus.register("super-admin--nested-form", NestedFormController)
+    window.Stimulus.register("super-admin--flash", FlashController)
+    window.Stimulus.register("super-admin--mobile-menu", MobileMenuController)
+  } else {
+    console.warn("SuperAdmin: Stimulus not found. Controllers will not be registered.")
+  }
+}
+
+// Register immediately if Stimulus is already loaded
+if (window.Stimulus) {
+  registerControllers()
+} else {
+  // Otherwise wait for Stimulus to load
+  document.addEventListener("DOMContentLoaded", () => {
+    setTimeout(registerControllers, 100)
+  })
+}

data/app/jobs/super_admin/application_job.rb

@@ -0,0 +1,4 @@
+module SuperAdmin
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/super_admin/generate_super_admin_csv_export_job.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# Generates a CSV export in the background for SuperAdmin.
+module SuperAdmin
+  class GenerateSuperAdminCsvExportJob < ApplicationJob
+    queue_as :default
+
+    def perform(export_reference = nil, **options)
+      export = nil
+      args = normalize_arguments(export_reference, options)
+
+      export = SuperAdmin::CsvExport.find(args.fetch(:export_id))
+      export.mark_processing!
+
+      model_class_name = args[:model_class_name] || export.model_class_name || export.resource_name.classify
+      model_class = SuperAdmin::ModelInspector.find_model(model_class_name) || SuperAdmin::ModelInspector.find_model(export.resource_name)
+      raise ActiveRecord::RecordNotFound, export.resource_name unless model_class
+
+      scope = SuperAdmin::ResourceQuery.filtered_scope(
+        model_class,
+        search: export.search,
+        sort: export.sort,
+        direction: export.direction,
+        filters: export.filters
+      )
+
+      if args[:scope_params].present? && scope.respond_to?(:merge)
+        scope = scope.merge(model_class.where(args[:scope_params]))
+      end
+
+      records_count = scope.count
+
+      exporter = SuperAdmin::ResourceExporter.new(
+        model_class,
+        scope,
+        attributes: args[:attributes].presence || export.selected_attributes.presence || SuperAdmin::DashboardResolver.collection_attributes_for(model_class)
+      )
+
+  attach_csv(export, exporter)
+      export.mark_ready!(records_count: records_count)
+    rescue StandardError => error
+      export_identifier = (args && args[:export_id]) || export&.id
+      Rails.logger.error("[SuperAdmin::GenerateSuperAdminCsvExportJob] Export ##{export_identifier} failed: #{error.class} - #{error.message}")
+      export&.mark_failed!(error.message)
+      raise
+    ensure
+      cleanup_tempfile
+    end
+
+    private
+
+    def normalize_arguments(export_reference, options)
+      params =
+        case export_reference
+        when Hash
+          export_reference
+        when nil
+          options
+        else
+          options.merge(export_id: export_reference)
+        end
+
+      params.to_h.transform_keys(&:to_sym)
+    end
+
+    def attach_csv(export, exporter)
+      @tempfile = Tempfile.new([ export.resource_name, ".csv" ], binmode: true)
+      exporter.write_to(@tempfile)
+      @tempfile.rewind
+
+      unless active_storage_available?
+        Rails.logger.warn("[SuperAdmin::GenerateSuperAdminCsvExportJob] ActiveStorage tables missing; skipping CSV attach for export ##{export.id}")
+        return
+      end
+
+      export.file.attach(
+        io: @tempfile,
+        filename: "#{export.resource_name}-#{Time.current.strftime('%Y%m%d-%H%M%S')}.csv",
+        content_type: "text/csv"
+      )
+    end
+
+    def active_storage_available?
+      return false unless defined?(ActiveStorage::Attachment)
+
+      ActiveStorage::Attachment.table_exists? && ActiveStorage::Blob.table_exists?
+    rescue ActiveRecord::StatementInvalid, ActiveRecord::NoDatabaseError
+      false
+    end
+
+    def cleanup_tempfile
+      return unless defined?(@tempfile) && @tempfile
+
+      @tempfile.close
+      @tempfile.unlink
+    rescue StandardError => error
+      Rails.logger.warn("[SuperAdmin::GenerateSuperAdminCsvExportJob] Tempfile cleanup warning: #{error.message}")
+    end
+  end
+end

data/app/mailers/super_admin/application_mailer.rb

@@ -0,0 +1,6 @@
+module SuperAdmin
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/super_admin/application_record.rb

@@ -0,0 +1,5 @@
+module SuperAdmin
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end