easy-admin-rails 0.1.0

data/app/controllers/easy_admin/resources_controller.rb

@@ -0,0 +1,907 @@
+module EasyAdmin
+  class ResourcesController < ApplicationController
+    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]
+
+    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]
+
+      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
+          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)
+          ]
+        end
+      end
+    end
+
+    def show
+    end
+
+    # Lazy loading endpoints for show page components
+    def metric
+      metric_config = find_metric_config(params[:metric_id])
+      render turbo_stream: turbo_stream.replace(
+        "metric-#{params[:metric_id]}",
+        EasyAdmin::LazyMetricCardComponent.new(metric_config: metric_config, record: @record)
+      )
+    end
+
+    def chart
+      chart_config = find_chart_config(params[:chart_id])
+      render turbo_stream: turbo_stream.replace(
+        "chart-#{params[:chart_id]}",
+        EasyAdmin::LazyChartCardComponent.new(chart_config: chart_config, record: @record)
+      )
+    end
+
+    def tab_content
+      tab_config = find_tab_config(params[:tab_name])
+      render turbo_stream: turbo_stream.replace(
+        "tab-#{params[:tab_name]}-content",
+        render_tab_elements(tab_config[:elements])
+      )
+    end
+
+    def new
+      @record = @resource_class.model_class.new
+    end
+
+    def create
+      @record = @resource_class.model_class.new(record_params)
+
+      if @record.save
+        redirect_to easy_admin.resource_path(@resource_class.route_key, @record),
+                    notice: "#{@resource_class.singular_title} was successfully created."
+      else
+        render :new
+      end
+    end
+
+    def edit
+    end
+
+    def update
+      Rails.logger.debug "Update called with params: #{record_params}"
+      Rails.logger.debug "Record before update: #{@record.inspect}"
+      
+      if @record.update(record_params)
+        Rails.logger.debug "Record after update: #{@record.reload.inspect}"
+        respond_to do |format|
+          format.html {
+            redirect_to easy_admin.resource_path(@resource_class.route_key, @record),
+                        notice: "#{@resource_class.singular_title} was successfully updated."
+          }
+          format.turbo_stream {
+            render turbo_stream: [
+              turbo_stream.update("notifications",
+                                  EasyAdmin::NotificationComponent.new(
+                                    type: :success,
+                                    message: "#{@resource_class.singular_title} was successfully updated!",
+                                    title: "Success"
+                                  ).call
+              )
+            ]
+          }
+        end
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      @record.destroy
+      redirect_to easy_admin.resources_path(@resource_class.route_key),
+                  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
+
+      # 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(@resource_class.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(@resource_class.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)
+      Rails.logger.debug "Permitted attributes: #{permitted_attrs}"
+      result = params.require(@resource_class.param_key).permit(*permitted_attrs)
+      Rails.logger.debug "Record params after permit: #{result}"
+      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|
+        element.object_id.to_s == metric_id
+      end
+    end
+
+    def find_chart_config(chart_id)
+      find_element_in_layout(@resource_class.show_layout, :chart_card) do |element|
+        element.object_id.to_s == chart_id
+      end
+    end
+
+    def find_tab_config(tab_name)
+      tabs_container = find_element_in_layout(@resource_class.show_layout, :tabs)
+      tabs_container[:tabs].find { |tab| tab[:name].downcase == tab_name }
+    end
+
+    def find_element_in_layout(layout, element_type, &block)
+      layout.each do |row|
+        next unless row[:type] == :row
+
+        row[:columns].each do |column|
+          column[:elements].each do |element|
+            case element[:type]
+            when element_type
+              return element if block.nil? || block.call(element)
+            when :card
+              result = find_element_in_card(element, element_type, &block)
+              return result if result
+            when :tabs
+              result = find_element_in_tabs(element, element_type, &block)
+              return result if result
+            end
+          end
+        end
+      end
+      nil
+    end
+
+    def find_element_in_card(card, element_type, &block)
+      card[:elements].each do |element|
+        case element[:type]
+        when element_type
+          return element if block.nil? || block.call(element)
+        when :tabs
+          result = find_element_in_tabs(element, element_type, &block)
+          return result if result
+        end
+      end
+      nil
+    end
+
+    def find_element_in_tabs(tabs, element_type, &block)
+      tabs[:tabs].each do |tab|
+        tab[:elements].each do |element|
+          return element if element[:type] == element_type && (block.nil? || block.call(element))
+        end
+      end
+      nil
+    end
+
+    def render_tab_elements(elements)
+      # This would render the tab elements - for now return a simple div
+      # In a real implementation, this would use the ShowLayoutComponent logic
+      content_tag(:div, class: "tab-content-loaded") do
+        "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
+  end
+end