flexi_admin 0.0.5 → 0.0.6

data/lib/flexi_admin/controllers/resources_controller.rb

@@ -2,19 +2,25 @@
 
 module FlexiAdmin::Controllers::ResourcesController
   extend ActiveSupport::Concern
+
+  DEFAULT_CONTROLLER_PARAMS_KEYS = %i[controller action subdomain commit button].freeze
   # rescue_from RuntimeError, with: :handle_runtime_error
 
   included do
+    helper FlexiAdmin::Helpers::ApplicationHelper
     before_action :context_params
 
-    rescue_from CanCan::AccessDenied do |exception|
-      flash[:error] = FlexiAdmin::Models::Toast.new(exception.message)
-      respond_to do |format|
-        format.html do
-          render 'shared/not_authorized'
-        end
-        format.turbo_stream do
-          render_toasts
+    if defined?(CanCan::AccessDenied)
+      rescue_from CanCan::AccessDenied do |exception|
+        flash[:error] = FlexiAdmin::Models::Toast.new(exception.message)
+        respond_to do |format|
+          format.html do
+            render 'shared/not_authorized'
+          end
+
+          format.turbo_stream do
+            render_toasts
+          end
         end
       end
     end
@@ -29,20 +35,32 @@ module FlexiAdmin::Controllers::ResourcesController
   end
 
   def render_index(resources, target: nil)
-    target ||= context_params.frame
+    target = target || (fa_sorting_active? ? resource_class.model_name.plural : context_params.frame)
+
     respond_to do |format|
       format.html do
-        component_class = "Admin::#{resource_class.name}::IndexPageComponent".constantize
-        puts "component_class: #{component_class}"
-        render component_class.new(resources, context_params:, scope: resource_class.to_s.downcase)
+        component_class = namespaced_class('namespace', resource_class.name, "IndexPageComponent")
+        puts("component_class: #{component_class}") if defined?(Rails) && Rails.env.development?
+        render component_class.new(resources, context_params: context_params,
+                                              scope: resource_class.model_name.plural)
       end
       format.turbo_stream do
-        component_class = "Admin::#{resource_class.name}::ResourcesComponent".constantize
-        render turbo_stream: turbo_stream.replace(target, component_class.new(resources, context_params:, scope: resource_class.to_s.downcase))
+        component_class = namespaced_class('namespace', resource_class.name, "ResourcesComponent")
+        render turbo_stream: turbo_stream.replace(target, component_class.new(resources, context_params: context_params,
+                                                                                         scope: resource_class.model_name.plural,
+                                                                                         parent: parent_instance))
       end
     end
   end
 
+  def reload_frame(scope = nil)
+    scope ||= context_params.reload_frame.presence || context_params.scope&.tr('/', '_') || resource_class.model_name.plural
+    render turbo_stream: [
+      turbo_stream.append('system', partial: 'shared/reload_frame', locals: { scope: scope, referrer: request.referrer }),
+      turbo_stream.append('toasts', partial: 'shared/toasts')
+    ]
+  end
+
   # Deprecated
   def reload_page
     render turbo_stream: [
@@ -52,17 +70,66 @@ module FlexiAdmin::Controllers::ResourcesController
   end
 
   def redirect_to_path(path)
-    render turbo_stream: turbo_stream.append('system', partial: 'shared/redirect', locals: { path: })
+    render turbo_stream: turbo_stream.append('system', partial: 'shared/redirect', locals: { path: path })
   end
 
+  # Prefix for the per-scope cookie that remembers a user's page-size choice.
+  PER_PAGE_COOKIE_PREFIX = "fa_per_page_"
+
   def context_params
-    @context_params ||= FlexiAdmin::Models::ContextParams.new(context_permitted_params)
+    @context_params ||= FlexiAdmin::Models::ContextParams.new(remembered_per_page_params)
   end
 
-  def context_permitted_params
-    @context_permitted_params ||= params.permit(*FlexiAdmin::Models::ContextParams.permitted_params_keys)
+  # Admin users work through long lists and were re-picking the same page size
+  # on every visit, because `fa_per_page` only ever lived in the URL. Persist
+  # the choice per scope in a cookie: an explicit `fa_per_page` is recorded,
+  # and a request without one inherits whatever that scope was last set to.
+  def remembered_per_page_params
+    permitted = context_permitted_params
+    cookie_key = per_page_cookie_key
+
+    chosen = permitted[FlexiAdmin::Models::ContextParams::MAP[:per_page]]
+    if chosen.present?
+      cookies[cookie_key] = { value: chosen.to_s, expires: 1.year.from_now } if valid_per_page?(chosen)
+      return permitted
+    end
+
+    remembered = cookies[cookie_key]
+    return permitted unless valid_per_page?(remembered)
+
+    permitted.merge(FlexiAdmin::Models::ContextParams::MAP[:per_page] => remembered)
+  end
+
+  # Keyed by scope where one is given (several scopes can render on one page),
+  # falling back to the controller for a plain index.
+  def per_page_cookie_key
+    scope = params[FlexiAdmin::Models::ContextParams::MAP[:scope]].presence || controller_path
+    "#{PER_PAGE_COOKIE_PREFIX}#{scope.to_s.parameterize(separator: '_')}"
   end
 
+  # A cookie is user-writable, so never let it widen a query beyond the sizes
+  # the app itself offers.
+  def valid_per_page?(value)
+    return false if value.blank?
+
+    FlexiAdmin::Config.configuration.paginate_per_options.map(&:to_s).include?(value.to_s)
+  end
+
+  def context_permitted_params
+    @context_permitted_params ||= begin
+      permitted_keys = FlexiAdmin::Models::ContextParams.permitted_params_keys.dup
+
+      array_param_keys = params.select { |_k, v| v.is_a?(Array) }.keys
+      array_params = array_param_keys.map { |k| { k => [] } }
+      scalar_params = params.except(:controller, *DEFAULT_CONTROLLER_PARAMS_KEYS).keys - array_param_keys
+
+      params.permit(
+        *permitted_keys,
+        *scalar_params,
+        *array_params
+      )
+    end
+  end
 
   def handle_runtime_error(error)
     return BugTracker.notify(error) if true
@@ -73,18 +140,29 @@ module FlexiAdmin::Controllers::ResourcesController
   end
 
   def create
-    authorize! :create, resource_class
+    authorize! :create, resource_class if defined?(CanCan)
 
-    create_service = begin
-      "#{resource_class.model_name.plural.camelize}::Services::Create".constantize
-    rescue NameError
-      FlexiAdmin::Services::CreateResource
-    end
+    result = nil
+    if respond_to?(:create_service)
+      Rails.logger.debug "ResourcesController: #{__method__} using custom controller create_service."
+      result = create_service(resource: parent_instance, params: resource_params)
+    else
+      create_service = begin
+        class_name = namespaced_class('namespace', resource_class.model_name.plural.camelize, "Services", "Create")
+        Rails.logger.debug "ResourcesController: #{__method__} using class_name: #{class_name}"
+        class_name
+      rescue NameError
+        Rails.logger.debug "ResourcesController: #{__method__} using generic FlexiAdmin::Services::CreateResource"
+        FlexiAdmin::Services::CreateResource
+      end
 
-    result = create_service.run(resource_class:, params: create_params)
+      result = create_service.run(resource_class:, params: resource_params)
+    end
 
     if result.valid?
-      redirect_to_path polymorphic_path([:admin, result.resource])
+      namespace = FlexiAdmin::Config.configuration.namespace
+      path_segments = namespace.present? ? [namespace.to_sym, result.resource] : [result.resource]
+      redirect_to_path polymorphic_path(path_segments)
     else
       render_new_resource_form(result.resource)
     end
@@ -92,12 +170,12 @@ module FlexiAdmin::Controllers::ResourcesController
 
   def show
     @resource = resource_class.find(params[:id])
-    authorize! :show, @resource
+    authorize! :show, @resource if defined?(CanCan)
 
     respond_to do |format|
       format.html do
-        component ||= "Admin::#{resource_class.name}::Show::PageComponent".constantize
-        render component.new(@resource, context_params:, scope: resource_class.to_s.downcase)
+        component ||= namespaced_class('namespace', resource_class.name, "Show", "PageComponent")
+        render component.new(@resource, context_params:, scope: resource_class.model_name.plural)
       end
       format.turbo_stream do
         render turbo_stream: turbo_stream.replace(context_params.frame)
@@ -107,30 +185,63 @@ module FlexiAdmin::Controllers::ResourcesController
 
   def edit
     @resource = resource_class.find(params[:id])
-    authorize! :update, @resource
+    authorize! :update, @resource if defined?(CanCan)
 
     render_edit_resource_form(disabled: disabled?(context_params.form_disabled))
   end
 
   def update
     @resource = resource_class.find(params[:id])
-    authorize! :update, @resource
+    authorize! :update, @resource if defined?(CanCan)
 
-    update_service = begin
-      "#{resource_class.model_name.plural.camelize}::Services::Update".constantize
-    rescue NameError
-      FlexiAdmin::Services::UpdateResource
-    end
+    result = nil
+    if result = try(:update_service, resource: @resource, params: resource_params)
+      Rails.logger.debug "ResourcesController: #{__method__} using custom controller update_service."
+      result = update_service(resource: @resource, params: resource_params)
+    else
+      update_service = begin
+        class_name = namespaced_class('namespace', 'namespace',"#{resource_class.model_name.plural.camelize}", "Services", "Update")
+        Rails.logger.debug "ResourcesController: #{__method__} using class_name: #{class_name}"
+
+        class_name
+      rescue NameError
+        Rails.logger.debug "ResourcesController: #{__method__} using generic FlexiAdmin::Services::UpdateResource"
+        FlexiAdmin::Services::UpdateResource
+      end
 
-    result = update_service.run(resource: @resource, params: resource_params)
+      result = update_service.run(resource: @resource, params: resource_params)
+    end
 
     if result.valid?
       render_edit_resource_form(disabled: disabled?(true))
     else
+      Rails.logger.debug "ResourcesController: #{__method__} errors: #{result.errors.respond_to?(:full_messages) ? result.errors.full_messages : result.errors}"
       render_edit_resource_form(disabled: disabled?(false))
     end
   end
 
+  def destroy
+    @resource = resource_class.find(params[:id])
+    authorize! :destroy, @resource if defined?(CanCan)
+
+    if @resource.destroy
+      success_message = I18n.t('flexi_admin.messages.destroy.success',
+                               resource: resource_class.model_name.human)
+      flash[:success] = FlexiAdmin::Models::Toast.new(success_message)
+
+      namespace = FlexiAdmin::Config.configuration.namespace
+      path_segments = namespace.present? ? [namespace.to_sym, resource_class] : [resource_class]
+      index_path = polymorphic_path(path_segments)
+
+      redirect_to_path index_path
+    else
+      error_message = I18n.t('flexi_admin.messages.destroy.failure',
+                            resource: resource_class.model_name.human)
+      flash[:error] = FlexiAdmin::Models::Toast.new(error_message)
+      render_toasts
+    end
+  end
+
   def render_edit_resource_form(disabled: true)
     respond_to do |format|
       format.html do
@@ -159,28 +270,58 @@ module FlexiAdmin::Controllers::ResourcesController
     # Unscoped is needed to get the resources that are not deleted, archived, etc.
     # It should be ok, since we control the ids in the frontend
     @resources = resource_class.unscoped.where(id: ids)
-    authorize! :edit, @resources
 
-    bulk_processor = "#{params[:processor].gsub('-', '/').camelize}::Processor".constantize.new(@resources, params)
+    authorize! :edit, @resources.presence&.base_class || resource_class if defined?(CanCan)
+
+    # TODO: improve this
+    params.merge!(current_user: current_user)
+    bulk_processor = if params[:processor].gsub('-', '/').camelize.include?(FlexiAdmin::Config.configuration.module_namespace)
+                      namespaced_class(params[:processor].gsub('-', '/').camelize, "Processor").new(@resources, params)
+    else
+      namespaced_class(FlexiAdmin::Config.configuration.module_namespace, params[:processor].gsub('-', '/').camelize, "Processor").new(@resources, params)
+    end
+
     result = bulk_processor.perform
 
     redirect_to_path result.path and return if result.result == :redirect
 
     flash[result.result] = FlexiAdmin::Models::Toast.new(result.message)
 
-    reload_page
+    if result.redirect_to.present?
+      redirect_to_path(result.redirect_to)
+    elsif result.try(:reload) == :page || context_params.reload == :page
+      reload_page
+    else
+      reload_frame
+    end
   end
 
-  def autocomplete(includes: nil)
-    base_query = resource_class.with_parent(parent_instance)
-                                .fulltext(params[:q])
+  def autocomplete(includes: nil, joins: nil, order: nil)
+    base_query = if context_params.params[:custom_scope].present?
+                   Rails.logger.debug "Autocomplete: custom scope: #{context_params.params[:custom_scope]}"
+                   apply_named_custom_scope(resource_class.with_parent(parent_instance), context_params.params[:custom_scope])
+                 else
+                   Rails.logger.debug "Autocomplete: no custom scope, using parent instance"
+                   resource_class.with_parent(parent_instance)
+                 end
+
+    # A focused-but-empty field asks for the default suggestions rather than
+    # running a fulltext search for "".
+    suggesting = params[:q].blank?
+    base_query = base_query.fulltext(params[:q]) unless suggesting
+    base_query = base_query.joins(joins) if joins.present?
     base_query = base_query.includes(includes) if includes.present?
+    base_query = base_query.order(order) if order.present?
+    Rails.logger.debug "Autocomplete: included #{includes.present? ? includes : "none"}"
+    Rails.logger.debug "Autocomplete: base_query SQL #{base_query.to_sql}"
+
     results_count = base_query.count
-    results = base_query.limit(100)
+    results = base_query.limit(suggesting ? FlexiAdmin::Config.configuration.autocomplete_suggestions : 100)
+    Rails.logger.debug "Autocomplete: base_query results after fulltext search: #{base_query.count}"
 
     render FlexiAdmin::Components::Shared::Autocomplete::ResultsComponent.new(results:,
-                                                                         results_count:,
-                                                                         context_params:), layout: false
+                                                                              results_count:,
+                                                                              context_params:), layout: false
   end
 
   def datalist
@@ -189,22 +330,25 @@ module FlexiAdmin::Controllers::ResourcesController
                             .order(*context_params.params[:ac_fields].map(&:to_sym))
                             .pluck(*context_params.params[:ac_fields].map(&:to_sym))
                             .uniq
+
     render FlexiAdmin::Components::Shared::Autocomplete::ResultsComponent.new(results:,
-                                                                         context_params:), layout: false
+                                                                              context_params:), layout: false
   end
 
   private
 
   def parent_instance
     @parent_instance ||= locate_resource(context_params.parent)
+    Rails.logger.debug "Parent instance: #{@parent_instance.present? ? format("@parent_instance: %s##{@parent_instance.id}", @parent_instance.class.name) : 'nil'}"
+    @parent_instance
   end
 
   def edit_form_component_instance(disabled)
-    [FlexiAdmin::NAMESPACE, "#{@resource.class.name}::Show::EditFormComponent"].join("::").constantize.new(@resource, disabled: disabled?(disabled))
+    namespaced_class('namespace', "#{@resource.class.name}", "Show", "EditFormComponent").new(@resource, disabled: disabled?(disabled))
   end
 
   def new_form_component_instance(resource)
-    "#{resource.class.name}::NewFormComponent".constantize.new(resource, parent: parent_instance)
+    namespaced_class('namespace', "#{resource.class.name}", "NewFormComponent").new(resource, parent: parent_instance)
   end
 
   def locate_resource(encoded_gid)
@@ -219,13 +363,30 @@ module FlexiAdmin::Controllers::ResourcesController
   end
 
   def resource_class
-    controller_name.classify.constantize
+    controller_path = self.class.name.deconstantize
+    config_namespace = FlexiAdmin::Config.configuration.namespace&.camelize
+
+    if config_namespace.present? && controller_path.start_with?(config_namespace)
+      if controller_path == config_namespace
+        controller_name.classify.constantize
+      else
+        module_path = controller_path.sub(/^#{Regexp.escape(config_namespace)}::/, '')
+        class_name = "#{module_path}::#{controller_name.classify}"
+        Object.const_get(class_name)
+      end
+    else
+      controller_name.classify.constantize
+    end
   end
 
   def fa_sorted?
     fa_sort.present? && fa_order.present? && fa_order != "default"
   end
 
+  def fa_sorting_active?
+    fa_sort.present? && fa_order.present?
+  end
+
   def fa_sort
     context_params[:sort]
   end
@@ -235,6 +396,40 @@ module FlexiAdmin::Controllers::ResourcesController
   end
 
   def disabled?(form_disabled = false)
-    !current_ability&.can?(:update, resource_class) || form_disabled
+    if defined?(CanCan)
+      !current_ability&.can?(:update, resource_class) || form_disabled
+    else
+      form_disabled
+    end
+  end
+
+  def namespaced_class(*segments)
+    config_namespace = FlexiAdmin::Config.configuration.namespace&.camelize
+
+    modules = segments.compact.flat_map do |segment|
+      if segment == 'namespace'
+        config_namespace
+      elsif segment.include?('::')
+        segment.split('::')
+      else
+        segment
+      end
+    end.compact
+
+    modules.join("::").constantize
+  rescue NameError => e
+    Rails.logger.warn "Failed to find class: #{modules.join("::")}"
+    raise NameError, "Failed to find class: #{modules.join("::")}"
+  end
+
+  def apply_named_custom_scope(scoped_resource_class, scope_name)
+    scope_name = scope_name.to_sym
+
+    unless scoped_resource_class.respond_to?(:fa_allowed_scopes) && scoped_resource_class.fa_allowed_scopes.include?(scope_name)
+      raise ArgumentError, "Scope '#{scope_name}' is not whitelisted for #{scoped_resource_class}. " \
+                           "Add it to fa_allowed_scopes in the model."
+    end
+
+    scoped_resource_class.public_send(scope_name)
   end
 end

data/lib/flexi_admin/engine.rb

@@ -4,6 +4,10 @@ module FlexiAdmin
   class Engine < ::Rails::Engine
     isolate_namespace FlexiAdmin
 
+    initializer "flexi_admin.locale" do
+      config.i18n.load_path += Dir[root.join('config', 'locales', '*.yml')]
+    end
+
     initializer "flexi_admin.assets" do |app|
       app.config.assets.precompile += %w[flexi_admin_main.scss flexi_admin.js]
       app.config.assets.paths << root.join("app/flexi_admin/javascript")

data/lib/flexi_admin/helpers/application_helper.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
 
 module FlexiAdmin::Helpers::ApplicationHelper
+  def toast_class(flash_type)
+    { success: 'bg-primary', error: 'bg-danger', alert: 'bg-warning', notice: 'bg-primary' }[flash_type.to_sym]
+  end
 end

data/lib/flexi_admin/javascript/controllers/add_row_controller.js

@@ -0,0 +1,118 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static values = {
+    container: String,
+    templateSelector: { type: String, default: '.dynamic-rows > .form-row' }
+  }
+
+  connect() {
+    // Initialize remove button visibility on page load
+    const containerSelector = this.containerValue || this.element.dataset.addRowContainerValue
+    if (containerSelector) {
+      const container = document.querySelector(containerSelector)
+      if (container) {
+        this.updateRemoveButtonsVisibility(container)
+      }
+    }
+  }
+
+  add(event) {
+    event.preventDefault()
+
+    const button = event.target.closest('button')
+    const containerSelector = button?.dataset.addRowContainerValue || this.containerValue
+    const templateSelector = button?.dataset.addRowTemplateSelectorValue || this.templateSelectorValue
+
+    // Store the container selector on the controller element for future use
+    if (containerSelector && !this.containerValue) {
+      this.element.dataset.addRowContainerValue = containerSelector
+      this.containerValue = containerSelector
+    }
+
+    const container = document.querySelector(containerSelector)
+    if (!container) {
+      return
+    }
+
+    // Get only direct children matching the template selector
+    const templates = Array.from(container.children).filter(child =>
+      child.matches(templateSelector)
+    )
+
+    if (templates.length === 0) {
+      return
+    }
+
+    const lastTemplate = templates[templates.length - 1]
+    const clone = lastTemplate.cloneNode(true)
+
+    // Mark the cloned row as removable
+    clone.dataset.removable = 'true'
+
+    const inputs = clone.querySelectorAll('input, select, textarea')
+    inputs.forEach(input => {
+      if (input.name) {
+        input.name = input.name.replace(/\[(\d+)\]/g, (match, num) => {
+          return `[${parseInt(num) + 1}]`
+        })
+      }
+      // Clear values for new row
+      if (input.tagName === 'SELECT') {
+        input.selectedIndex = 0
+      } else {
+        input.value = ''
+      }
+
+      input.classList.remove('is-invalid')
+      const feedback = input.closest('.field-wrapper')?.querySelector('.invalid-feedback')
+      if (feedback) feedback.remove()
+    })
+
+    const labels = clone.querySelectorAll('label')
+    labels.forEach(label => {
+      if (label.textContent) {
+        label.textContent = label.textContent.replace(/(\d+)/g, (match, num) => {
+          return parseInt(num) + 1
+        })
+      }
+    })
+
+    container.appendChild(clone)
+    this.updateRemoveButtonsVisibility(container)
+  }
+
+  remove(event) {
+    event.preventDefault()
+
+    const button = event.target.closest('button')
+    const templateSelector = button?.dataset.addRowTemplateSelectorValue || this.templateSelectorValue || '.form-row'
+
+    const row = event.target.closest(templateSelector)
+    if (row) {
+      const container = row.parentElement
+      const rows = container.querySelectorAll(templateSelector)
+
+      // Prevent removing the last row
+      if (rows.length <= 1) {
+        return
+      }
+
+      row.remove()
+      this.updateRemoveButtonsVisibility(container)
+    }
+  }
+
+  updateRemoveButtonsVisibility(container) {
+    const templateSelector = this.templateSelectorValue || '.form-row'
+    const rows = Array.from(container.children).filter(child =>
+      child.matches(templateSelector)
+    )
+    const removeButtons = container.querySelectorAll('button[data-action*="add-row#remove"]')
+
+    const shouldShow = rows.length > 1
+    removeButtons.forEach(button => {
+      button.style.display = shouldShow ? '' : 'none'
+    })
+  }
+}

data/lib/flexi_admin/javascript/controllers/autocomplete_controller.js

@@ -30,6 +30,17 @@ export default class extends Controller {
     this.hideResults();
   }
 
+  // Opening an empty field used to show nothing at all, so a user faced with a
+  // long list had to guess a search term before seeing a single option. Focus
+  // now asks the backend for its default suggestions.
+  focus() {
+    if (this.inputTarget.disabled) return;
+    if (this.inputTarget.value.length > 0) return;
+
+    this.listTarget.classList.remove("d-none");
+    this._search("");
+  }
+
   keyup(event) {
     if (this.inputTarget.value.length > 0) {
       this.listTarget.classList.remove("d-none");
@@ -45,7 +56,7 @@ export default class extends Controller {
 
     this.timeout = setTimeout(() => {
       this._search(this.inputTarget.value);
-    }, 200);
+    }, 300);
   }
 
   hideResults() {
@@ -118,6 +129,11 @@ export default class extends Controller {
     const url = new URL(path, window.location.origin);
     url.searchParams.set("q", string);
 
+    // An app may mark one record as the one the user is working on, so the
+    // backend can float it to the top of an otherwise arbitrary list.
+    const priority = this.inputTarget.dataset.autocompletePriorityValue;
+    if (priority) url.searchParams.set("ac_priority", priority);
+
     try {
       this.loadingIconTarget.classList.remove("d-none"); // Show loading icon
       const response = await fetch(url.toString(), {