easy-admin-rails 0.1.15 → 0.2.1

data/app/controllers/easy_admin/resources_controller.rb

@@ -2,114 +2,31 @@ module EasyAdmin
   class ResourcesController < ApplicationController
     include EasyAdmin::ResourceVersions
     
-    before_action :load_resource_class
-    before_action :load_record, only: [:show, :edit, :update, :destroy, :edit_field, :update_field, :belongs_to_reattach, :belongs_to_edit_attached, :update_belongs_to_attached, :versions, :revert_version, :version_diff]
+    # Include concerns for better organization
+    include EasyAdmin::Concerns::ResourceLoading
+    include EasyAdmin::Concerns::ResourceFiltering
+    include EasyAdmin::Concerns::ResourcePagination  
+    include EasyAdmin::Concerns::InlineFieldEditing
+    include EasyAdmin::Concerns::BelongsToEditing
+    include EasyAdmin::Concerns::ResourceAuthorization
 
     def index
-      # Set up data needed for both HTML and turbo stream
-      sort_field = params[:sort]
-      sort_direction = params[:direction] == 'desc' ? 'desc' : 'asc'
-      
-      # Handle scope filtering
-      @current_scope = determine_current_scope
-      
-      # Only calculate scope counts for HTML requests, not for infinite scroll (turbo_stream)
-      if @resource_class.has_scopes? && !request.format.turbo_stream?
-        @scope_counts = calculate_scope_counts
-      end
-
-      # Start with base records (ensure we have a relation, not just a class)
-      @records = apply_scope(@resource_class.model_class.all)
-      
-      # Apply eager loading for index action
-      if @resource_class.index_includes.any?
-        @records = @records.includes(@resource_class.index_includes)
-      end
-
-      # Apply Ransack filtering if present
-      if params[:q].present?
-        @search_query = @records.ransack(params[:q])
-        @records = @search_query.result
-      end
-
-      # Apply text search if present (fallback/additional search)
-      if params[:search].present?
-        @records = @resource_class.search_records(params[:search], sort_field: sort_field, sort_direction: sort_direction, records: @records)
-      else
-        @records = apply_sorting(@records, sort_field, sort_direction)
-      end
-
-      # Apply period filtering
-      @records = apply_period_filter(@records)
-
-      # Apply pagination using Pagy with resource-specific configuration
-      items_per_page = @resource_class.respond_to?(:items_per_page) ? @resource_class.items_per_page : 20
-      
-      # Reset to page 1 if filtering/searching is applied to avoid overflow
-      current_page = if has_active_filters?
-        1
-      else
-        params[:page] || 1
-      end
-      
-      pagination_options = {
-        items: items_per_page,
-        limit: items_per_page,
-        page: current_page,
-        overflow: :last_page  # Handle overflow by redirecting to last valid page
-      }
-
-      # Use countless pagination if enabled for performance
-      if @resource_class.respond_to?(:countless_enabled?) && @resource_class.countless_enabled?
-        @pagy, @records = pagy_countless(@records, **pagination_options)
-      else
-        @pagy, @records = pagy(@records, **pagination_options)
-      end
-      @current_sort_field = sort_field
-      @current_sort_direction = sort_direction
-      @current_period = params[:period]
+      # Prepare pagination data using concern methods
+      prepare_index_pagination_data
 
       respond_to do |format|
         format.html do
           # Check if this is a turbo frame request
           if turbo_frame_request?
-            render plain: EasyAdmin::Resources::IndexFrameComponent.new(
-              resource_class: @resource_class,
-              records: @records,
-              pagy: @pagy,
-              current_params: params.permit(:search, :scope, :sort, :direction, :period, :page, q: {}),
-              current_path: request.path,
-              current_user: current_admin_user
-            ).call
+            @current_params = params.permit(:search, :scope, :sort, :direction, :period, :page, q: {})
+            render template: 'easy_admin/resources/index_frame', layout: false
           else
             # Regular page load - shows skeleton with layout
             # Will render app/views/easy_admin/resources/index.html.erb
           end
         end
         format.turbo_stream do
-          # For infinite scroll - append new rows to existing table
-          table_rows_html = @records.map do |record|
-            EasyAdmin::Resources::TableRowComponent.new(
-              record: record,
-              resource_class: @resource_class
-            ).call
-          end.join.html_safe
-
-          render turbo_stream: [
-            turbo_stream.append("records-container", table_rows_html),
-            turbo_stream.replace("infinite-scroll-container", EasyAdmin::InfiniteScrollComponent.new(
-              pagy: @pagy,
-              resource_class: @resource_class,
-              current_params: params.permit(:search, :scope, :sort, :direction, :period, :page, q: {}),
-              current_path: request.path
-            ).call),
-            turbo_stream.replace("combined-filters", EasyAdmin::CombinedFiltersComponent.new(
-              resource_class: @resource_class,
-              current_params: params.permit(:search, :scope, :sort, :direction, :period, :page, q: {}),
-              search_params: params[:q] || {},
-              current_period: @current_period
-            ).call)
-          ]
+          render turbo_stream: build_infinite_scroll_turbo_stream
         end
       end
     end
@@ -194,640 +111,8 @@ module EasyAdmin
                   notice: "#{@resource_class.singular_title} was successfully deleted."
     end
 
-    # Inline field editing actions
-    def edit_field
-      @field_name = params[:field]
-      @field_config = find_field_config(@field_name)
-      
-      unless @field_config
-        render json: { error: "Field '#{@field_name}' not found" }, status: :not_found
-        return
-      end
-
-      respond_to do |format|
-        format.html do
-          render plain: EasyAdmin::Fields::InlineEditModalComponent.new(
-            record: @record,
-            field_config: @field_config,
-            resource_class: @resource_class
-          ).call
-        end
-        format.turbo_stream do
-          render turbo_stream: turbo_stream.update("modal", 
-            EasyAdmin::Fields::InlineEditModalComponent.new(
-              record: @record,
-              field_config: @field_config,
-              resource_class: @resource_class
-            ).call
-          )
-        end
-      end
-    end
-
-    def update_field
-      @field_name = params[:field]
-      @field_config = find_field_config(@field_name)
-      
-      unless @field_config
-        render json: { error: "Field '#{@field_name}' not found" }, status: :not_found
-        return
-      end
-
-      # Determine the correct parameter key (handle complex model names)
-      param_key = determine_param_key_for_update_field
-      
-      # For belongs_to fields, we need to handle foreign key updates
-      if @field_config[:type] == :belongs_to
-        association_name = @field_config[:name]
-        foreign_key = get_foreign_key_name(association_name)
-        field_value = params.dig(param_key, foreign_key)
-        update_attrs = { foreign_key.to_sym => field_value }
-      else
-        # Create a field object to handle normalization
-        field_obj = EasyAdmin::Field.new(@field_name, @field_config[:type], @field_config)
-        
-        # Get the field value from params
-        field_value = params.dig(param_key, @field_name)
-        
-        # Normalize the input
-        update_attrs = { @field_name => field_value }
-        field_obj.normalize_input!(update_attrs)
-      end
-
-      if @record.update(update_attrs)
-        respond_to do |format|
-          format.turbo_stream do
-            # Update the table cell with the new value
-            render turbo_stream: [
-              turbo_stream.replace(
-                "#{helpers.dom_id(@record)}_#{@field_name}",
-                EasyAdmin::Resources::TableCellComponent.new(
-                  record: @record.reload,
-                  field_config: @field_config,
-                  resource_class: @resource_class
-                ).call
-              ),
-              turbo_stream.update("notifications",
-                EasyAdmin::NotificationComponent.new(
-                  type: :success,
-                  message: "#{@field_config[:label]} updated successfully!",
-                  title: "Success"
-                ).call
-              )
-            ]
-          end
-          format.json { render json: { status: 'success' } }
-        end
-      else
-        respond_to do |format|
-          format.turbo_stream do
-            render turbo_stream: turbo_stream.update("notifications",
-              EasyAdmin::NotificationComponent.new(
-                type: :error,
-                message: @record.errors.full_messages.join(', '),
-                title: "Error"
-              ).call
-            )
-          end
-          format.json { render json: { errors: @record.errors } }
-        end
-      end
-    end
-
-    def belongs_to_reattach
-      @field_name = params[:field]
-      @field_config = find_field_config(@field_name)
-      
-      unless @field_config
-        render json: { error: "Field '#{@field_name}' not found" }, status: :not_found
-        return
-      end
-
-      # Convert belongs_to field to select field format for reattaching
-      select_field_config = prepare_belongs_to_as_select(@field_config)
-
-      respond_to do |format|
-        format.html do
-          render plain: EasyAdmin::Fields::InlineEditModalComponent.new(
-            record: @record,
-            field_config: select_field_config,
-            resource_class: @resource_class
-          ).call
-        end
-      end
-    end
-
-    def belongs_to_edit_attached
-      @field_name = params[:field]
-      @field_config = find_field_config(@field_name)
-      
-      unless @field_config
-        render json: { error: "Field '#{@field_name}' not found" }, status: :not_found
-        return
-      end
-
-      unless @field_config[:type] == :belongs_to
-        render json: { error: "Field '#{@field_name}' is not a belongs_to field" }, status: :bad_request
-        return
-      end
-
-      # Get the associated record
-      associated_record = @record.public_send(@field_config[:name])
-      
-      unless associated_record
-        render json: { error: "No associated record found" }, status: :not_found
-        return
-      end
-
-      # Get the resource class for the associated record
-      association_name = @field_config[:name]
-      associated_model_class = @resource_class.model_class.reflect_on_association(association_name).klass
-      associated_resource_class = find_resource_class_for_model(associated_model_class)
-
-      unless associated_resource_class
-        render json: { error: "No resource class found for #{associated_model_class.name}" }, status: :not_found
-        return
-      end
-
-      respond_to do |format|
-        format.html do
-          render plain: EasyAdmin::Fields::BelongsToEditModalComponent.new(
-            record: associated_record,
-            resource_class: associated_resource_class,
-            parent_record: @record,
-            parent_field: @field_config
-          ).call
-        end
-        format.turbo_stream do
-          render turbo_stream: turbo_stream.update("modal",
-            EasyAdmin::Fields::BelongsToEditModalComponent.new(
-              record: associated_record,
-              resource_class: associated_resource_class,
-              parent_record: @record,
-              parent_field: @field_config
-            ).call
-          )
-        end
-      end
-    end
-
-    def update_belongs_to_attached
-      @field_name = params[:field]
-      @field_config = find_field_config(@field_name)
-      @attached_id = params[:attached_id]
-      
-      unless @field_config
-        render json: { error: "Field '#{@field_name}' not found" }, status: :not_found
-        return
-      end
-
-      # Get the associated record
-      association_name = @field_config[:name]
-      associated_model_class = @resource_class.model_class.reflect_on_association(association_name).klass
-      associated_resource_class = find_resource_class_for_model(associated_model_class)
-      
-      # Find the attached record
-      attached_record = associated_model_class.find(@attached_id)
-      
-      unless attached_record
-        render json: { error: "Attached record not found" }, status: :not_found
-        return
-      end
-
-      # Get the update parameters for the attached record
-      raw_params = params.dig(associated_resource_class.param_key) || {}
-      
-      # Get permitted attributes from the resource class
-      permitted_attributes = get_permitted_attributes(associated_resource_class)
-      update_params = raw_params.permit(*permitted_attributes)
-      
-      if attached_record.update(update_params)
-        respond_to do |format|
-          format.turbo_stream do
-            # Update the parent table cell to reflect any changes in the associated record
-            render turbo_stream: [
-              turbo_stream.replace(
-                "#{helpers.dom_id(@record)}_#{@field_name}",
-                EasyAdmin::Resources::TableCellComponent.new(
-                  record: @record.reload,
-                  field_config: @field_config,
-                  resource_class: @resource_class
-                ).call
-              ),
-              turbo_stream.update("notifications",
-                EasyAdmin::NotificationComponent.new(
-                  type: :success,
-                  message: "#{associated_resource_class.singular_title} updated successfully!",
-                  title: "Success"
-                ).call
-              )
-            ]
-          end
-        end
-      else
-        respond_to do |format|
-          format.turbo_stream do
-            render turbo_stream: turbo_stream.update("notifications",
-              EasyAdmin::NotificationComponent.new(
-                type: :error,
-                message: attached_record.errors.full_messages.join(', '),
-                title: "Error"
-              ).call
-            )
-          end
-        end
-      end
-    end
-
-    def suggest
-      field_config = @resource_class.fields_config.find { |f| f[:name].to_s == params[:field] }
-      
-      Rails.logger.debug "Suggest field_config for #{params[:field]}: #{field_config}"
-      
-      unless field_config && field_config[:suggest]
-        render json: { error: "Field not found or suggest not configured" }, status: :not_found
-        return
-      end
-      
-      search_term = params[:q].to_s.strip
-      limit = field_config[:suggest][:limit] || 10
-      
-      results = get_suggest_options(field_config, search_term, limit)
-      
-      render json: { options: results }
-    end
-
     private
 
-    def load_resource_class
-      resource_name = params[:resource_name]
-      @resource_class = EasyAdmin::ResourceRegistry.find_resource(resource_name)
-
-      unless @resource_class
-        raise ActionController::RoutingError, "Resource '#{resource_name}' not found"
-      end
-    end
-
-    def load_record
-      @record = @resource_class.find_record(params[:id])
-    end
-
-    def record_params
-      permitted_attrs = get_permitted_attributes(@resource_class)
-      
-      # Try resource param_key first, then fall back to model's natural param key
-      param_key = if params.key?(@resource_class.param_key)
-        @resource_class.param_key
-      elsif params.key?(@resource_class.model_class.model_name.param_key)
-        @resource_class.model_class.model_name.param_key
-      else
-        # Handle namespaced models that use slash format (e.g., "catalog/payment_method")
-        namespaced_param_key = @resource_class.model_class.name.underscore
-        params.key?(namespaced_param_key) ? namespaced_param_key : @resource_class.param_key
-      end
-      
-      result = params.require(param_key).permit(*permitted_attrs)
-      result
-    end
-    
-    def determine_current_scope
-      if params[:scope].present?
-        scope_config = @resource_class.scopes.find { |s| s[:name].to_s == params[:scope].to_s }
-        scope_config ? scope_config[:name] : @resource_class.default_scope&.dig(:name)
-      else
-        @resource_class.default_scope&.dig(:name)
-      end
-    end
-    
-    def apply_scope(records)
-      return records unless @resource_class.has_scopes? && @current_scope
-      
-      scope_config = @resource_class.scopes.find { |s| s[:name] == @current_scope }
-      
-      if scope_config && scope_config[:name] != :all
-        scope_method = scope_config[:scope_method]
-        if records.respond_to?(scope_method)
-          records.public_send(scope_method)
-        else
-          records
-        end
-      else
-        records
-      end
-    end
-    
-    def calculate_scope_counts
-      counts = {}
-      
-      @resource_class.scopes.each do |scope_config|
-        scope_name = scope_config[:name]
-        
-        if scope_name == :all
-          counts[scope_name] = @resource_class.model_class.count
-        else
-          scope_method = scope_config[:scope_method]
-          if @resource_class.model_class.respond_to?(scope_method)
-            counts[scope_name] = @resource_class.model_class.public_send(scope_method).count
-          else
-            counts[scope_name] = 0
-          end
-        end
-      end
-      
-      counts
-    end
-    
-    def apply_period_filter(records)
-      return records unless params[:period].present? && records.respond_to?(:where)
-      
-      date_range = case params[:period]
-                   when 'today'
-                     Date.current.beginning_of_day..Date.current.end_of_day
-                   when '7d'
-                     7.days.ago.beginning_of_day..Date.current.end_of_day
-                   when '30d'
-                     30.days.ago.beginning_of_day..Date.current.end_of_day
-                   when '90d'
-                     90.days.ago.beginning_of_day..Date.current.end_of_day
-                   when '1y'
-                     1.year.ago.beginning_of_day..Date.current.end_of_day
-                   else
-                     return records
-                   end
-      
-      # Try to filter by created_at, updated_at, or the first timestamp field
-      timestamp_field = determine_timestamp_field(records)
-      return records unless timestamp_field
-      
-      records.where(timestamp_field => date_range)
-    end
-    
-    def find_field_config(field_name)
-      @resource_class.fields_config.find { |field| field[:name].to_s == field_name.to_s }
-    end
-
-    def find_resource_class_for_model(model_class)
-      # Try to find the resource class by convention (e.g., User -> UserResource)
-      resource_class_name = "#{model_class.name}Resource"
-      begin
-        resource_class_name.constantize
-      rescue NameError
-        # If convention doesn't work, search through all resource classes
-        EasyAdmin.resource_registry.values.find { |rc| rc.model_class == model_class }
-      end
-    end
-
-    def get_permitted_attributes(resource_class)
-      # Get all editable field names from the resource class
-      permitted_attrs = []
-      
-      resource_class.form_fields.each do |field_config|
-        next if field_config[:readonly]
-        
-        field_name = field_config[:name]
-        
-        # Handle different field types that might need special parameter handling
-        case field_config[:type]
-        when :has_many
-          # For has_many relationships, we need to permit an array of IDs
-          permitted_attrs << { "#{field_name.to_s.singularize}_ids" => [] }
-        when :belongs_to
-          # For belongs_to, we need the foreign key
-          if field_config[:multiple]
-            permitted_attrs << { "#{field_name}_ids" => [] }
-          else
-            foreign_key = get_foreign_key_name(field_name)
-            permitted_attrs << foreign_key.to_sym
-          end
-        when :select
-          # For select fields with multiple option
-          if field_config[:multiple]
-            permitted_attrs << { field_name => [] }
-          else
-            permitted_attrs << field_name
-          end
-        else
-          # For regular fields
-          permitted_attrs << field_name
-        end
-      end
-      
-      permitted_attrs
-    end
-    
-    def prepare_belongs_to_as_select(field_config)
-      # Convert belongs_to field to select field for reattaching
-      association_name = field_config[:name]
-      foreign_key = get_foreign_key_name(association_name)
-      
-      # Get available options for the select
-      options = get_belongs_to_options(association_name, field_config)
-      
-      # Return field config formatted as a select field, preserving original info
-      field_config.merge(
-        type: :select,
-        name: foreign_key, # Use foreign key instead of association name
-        label: "Select #{field_config[:label]}",
-        options: options,
-        original_type: :belongs_to,
-        original_name: association_name
-      )
-    end
-    
-    def get_foreign_key_name(association_name)
-      model_class = @resource_class.model_class
-      if model_class.reflect_on_association(association_name)
-        model_class.reflect_on_association(association_name).foreign_key
-      else
-        "#{association_name}_id"
-      end
-    end
-    
-    def get_belongs_to_options(association_name, field_config)
-      model_class = @resource_class.model_class
-      
-      # Get the associated model class
-      if model_class.reflect_on_association(association_name)
-        association_class = model_class.reflect_on_association(association_name).klass
-      else
-        association_class = association_name.to_s.classify.constantize rescue nil
-      end
-      
-      return [] unless association_class
-      
-      # Get display method from field config
-      display_method = field_config[:display_method] || :name
-      
-      # Get all records and format as [label, value] pairs
-      association_class.all.limit(100).map do |record|
-        label = if record.respond_to?(display_method)
-          record.public_send(display_method)
-        elsif record.respond_to?(:name)
-          record.name
-        elsif record.respond_to?(:title)
-          record.title
-        else
-          record.to_s
-        end
-        [label, record.id]
-      end
-    end
-
-    def get_suggest_options(field_config, search_term, limit)
-      # Handle different field types that support suggest
-      case field_config[:type]
-      when :belongs_to
-        get_belongs_to_suggest_options(field_config[:name], field_config, search_term, limit)
-      when :has_many
-        get_has_many_suggest_options(field_config[:name], field_config, search_term, limit)
-      when :select
-        # For regular select fields, filter static options
-        get_static_suggest_options(field_config, search_term, limit)
-      else
-        []
-      end
-    end
-
-    def get_belongs_to_suggest_options(association_name, field_config, search_term, limit)
-      model_class = @resource_class.model_class
-      
-      # Get the associated model class
-      if model_class.reflect_on_association(association_name)
-        association_class = model_class.reflect_on_association(association_name).klass
-      else
-        association_class = association_name.to_s.classify.constantize rescue nil
-      end
-      
-      return [] unless association_class
-      
-      # Get display method and search fields from field config
-      display_method = field_config[:display_method] || :name
-      suggest_config = field_config[:suggest] || {}
-      search_fields = suggest_config[:search_fields] || [display_method]
-      
-      # Build search query
-      records = association_class.all
-      
-      if search_term.present?
-        # Build WHERE conditions for search across multiple fields
-        conditions = search_fields.map do |field|
-          if association_class.columns_hash[field.to_s]&.type == :string
-            "#{field} LIKE ?"
-          else
-            "CAST(#{field} AS TEXT) LIKE ?"
-          end
-        end.join(" OR ")
-        
-        search_pattern = "%#{search_term}%"
-        records = records.where(conditions, *([search_pattern] * search_fields.length))
-      end
-      
-      # Apply limit and format as [label, value] pairs
-      records.limit(limit).map do |record|
-        label = if record.respond_to?(display_method)
-          record.public_send(display_method)
-        elsif record.respond_to?(:name)
-          record.name
-        elsif record.respond_to?(:title)
-          record.title
-        else
-          record.to_s
-        end
-        [label, record.id]
-      end
-    end
-
-    def get_has_many_suggest_options(association_name, field_config, search_term, limit)
-      model_class = @resource_class.model_class
-      
-      # Get the associated model class
-      if model_class.reflect_on_association(association_name)
-        association_class = model_class.reflect_on_association(association_name).klass
-      else
-        association_class = association_name.to_s.singularize.classify.constantize rescue nil
-      end
-      
-      return [] unless association_class
-      
-      # Get display method and search fields from field config
-      display_method = field_config[:display_method] || :name
-      suggest_config = field_config[:suggest] || {}
-      search_fields = suggest_config[:search_fields] || [display_method]
-      
-      Rails.logger.debug "HasMany suggest: association=#{association_name}, display_method=#{display_method}, search_fields=#{search_fields}"
-      
-      # Build search query
-      records = association_class.all
-      
-      if search_term.present?
-        # Build WHERE conditions for search across multiple fields
-        conditions = search_fields.map do |field|
-          if association_class.columns_hash[field.to_s]&.type == :string
-            "#{field} LIKE ?"
-          else
-            "CAST(#{field} AS TEXT) LIKE ?"
-          end
-        end.join(" OR ")
-        
-        search_pattern = "%#{search_term}%"
-        records = records.where(conditions, *([search_pattern] * search_fields.length))
-      end
-      
-      # Apply limit and format as [label, value] pairs
-      results = records.limit(limit).map do |record|
-        label = if record.respond_to?(display_method)
-          raw_label = record.public_send(display_method)
-          Rails.logger.debug "HasMany record #{record.id}: raw_label=#{raw_label.class}:#{raw_label}"
-          raw_label.to_s
-        elsif record.respond_to?(:name)
-          record.name.to_s
-        elsif record.respond_to?(:title)
-          record.title.to_s
-        else
-          record.to_s
-        end
-        [label, record.id]
-      end
-      
-      Rails.logger.debug "HasMany suggest final results: #{results}"
-      results
-    end
-
-    def get_static_suggest_options(field_config, search_term, limit)
-      options = field_config[:options] || []
-      
-      if search_term.present?
-        # Filter options based on search term
-        filtered_options = options.select do |option|
-          text = option.is_a?(Array) ? option[0] : option.to_s
-          text.downcase.include?(search_term.downcase)
-        end
-        filtered_options.take(limit)
-      else
-        options.take(limit)
-      end
-    end
-    
-    def determine_timestamp_field(records)
-      # Get the model class from the relation or class
-      model_class = if records.is_a?(Class) && records < ActiveRecord::Base
-                      # If records is already an ActiveRecord model class
-                      records
-                    elsif records.respond_to?(:klass)
-                      # For ActiveRecord relations
-                      records.klass
-                    elsif records.respond_to?(:model)
-                      records.model
-                    else
-                      records.class
-                    end
-      
-      # Try common timestamp fields in order of preference
-      %w[created_at updated_at published_at date timestamp].find do |field|
-        model_class.column_names.include?(field)
-      end
-    end
-
     # Helper methods for lazy loading
     def find_metric_config(metric_id)
       find_element_in_layout(@resource_class.show_layout, :metric_card) do |element|
@@ -897,39 +182,5 @@ module EasyAdmin
         "Tab content loaded"
       end
     end
-
-    def apply_sorting(records, sort_field, sort_direction)
-      return records unless sort_field.present?
-      
-      # Get the model class from the relation
-      model_class = records.respond_to?(:klass) ? records.klass : records.class
-      
-      if records.respond_to?(:order) && model_class.column_names.include?(sort_field.to_s)
-        records.order("#{sort_field} #{sort_direction}")
-      else
-        records
-      end
-    end
-    
-    def has_active_filters?
-      # Check if any filtering parameters are present
-      params[:q].present? || 
-      params[:search].present? || 
-      params[:period].present? ||
-      (params[:scope].present? && params[:scope] != determine_current_scope[:scope])
-    end
-    
-    def determine_param_key_for_update_field
-      # Try resource param_key first, then fall back to model's natural param key
-      if params.key?(@resource_class.param_key)
-        @resource_class.param_key
-      elsif params.key?(@resource_class.model_class.model_name.param_key)
-        @resource_class.model_class.model_name.param_key
-      else
-        # Handle namespaced models that use slash format (e.g., "catalog/payment_method")
-        namespaced_param_key = @resource_class.model_class.name.underscore
-        params.key?(namespaced_param_key) ? namespaced_param_key : @resource_class.param_key
-      end
-    end
   end
-end
+end