easy-admin-rails 0.1.14 → 0.2.0

data/app/controllers/easy_admin/concerns/resource_filtering.rb

@@ -0,0 +1,178 @@
+module EasyAdmin
+  module Concerns
+    # ResourceFiltering concern handles all filtering, searching, and scoping logic
+    # Provides methods for applying scopes, search, period filters, and sorting
+    module ResourceFiltering
+      extend ActiveSupport::Concern
+
+      private
+
+      # Determine the current scope based on params and resource configuration
+      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
+
+      # Apply scope filtering to records
+      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
+
+      # Calculate counts for all scopes (for scope filters UI)
+      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
+
+      # Apply period-based filtering (today, 7d, 30d, etc.)
+      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
+
+      # Apply sorting to records
+      def apply_sorting(records, sort_field, sort_direction)
+        # Always apply sorting if sort_field is present
+        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
+
+      # Check if any filtering parameters are active
+      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].to_s != @resource_class.default_scope&.dig(:name).to_s)
+      end
+
+      # Determine the best timestamp field for period filtering
+      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
+
+      # Apply Ransack search filtering
+      def apply_ransack_search(records)
+        return records unless params[:q].present?
+        
+        @search_query = records.ransack(params[:q])
+        @search_query.result
+      end
+
+      # Apply text-based search (fallback when Ransack not used)
+      def apply_text_search(records, sort_field, sort_direction)
+        return records unless params[:search].present?
+        
+        @resource_class.search_records(
+          params[:search], 
+          sort_field: sort_field, 
+          sort_direction: sort_direction, 
+          records: records
+        )
+      end
+
+      # Build the filtered and sorted record set
+      def build_filtered_records(sort_field, sort_direction)
+        # 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
+        records = apply_ransack_search(records)
+
+        # Apply text search if present (fallback/additional search)
+        if params[:search].present?
+          records = apply_text_search(records, sort_field, sort_direction)
+        else
+          records = apply_sorting(records, sort_field, sort_direction)
+        end
+
+        # Apply period filtering
+        records = apply_period_filter(records)
+
+        records
+      end
+    end
+  end
+end

data/app/controllers/easy_admin/concerns/resource_loading.rb

@@ -0,0 +1,149 @@
+module EasyAdmin
+  module Concerns
+    # ResourceLoading concern handles loading resource classes and individual records
+    # Provides before_action callbacks and helper methods for resource/record loading
+    module ResourceLoading
+      extend ActiveSupport::Concern
+
+      included do
+        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
+        ]
+      end
+
+      private
+
+      # Load the resource class based on the route parameter
+      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
+
+      # Load individual record for actions that operate on a specific record
+      def load_record
+        @record = @resource_class.find_record(params[:id])
+      end
+
+      # Helper method to find field configuration
+      def find_field_config(field_name)
+        @resource_class.fields_config.find { |field| field[:name].to_s == field_name.to_s }
+      end
+
+      # Helper method to find resource class for a given model
+      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
+
+      # Get permitted attributes for a resource class
+      def get_permitted_attributes(resource_class)
+        # Get all editable field names from the resource class
+        permitted_attrs = []
+        
+        # Check both form fields and all fields (including hidden ones)
+        all_fields = resource_class.form_fields + resource_class.fields_config
+        unique_fields = all_fields.uniq { |f| f[:name] }
+        
+        Rails.logger.debug "🔍 [ResourceLoading] All fields for #{resource_class}:"
+        unique_fields.each_with_index do |field_config, index|
+          Rails.logger.debug "🔍 [ResourceLoading] Field #{index}: #{field_config[:name]} (type: #{field_config[:type]}, readonly: #{field_config[:readonly]})"
+          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
+              association_name = field_config[:association] || field_name
+              foreign_key = get_foreign_key_name(association_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
+          when :json
+            # For JSON fields, permit nested parameters as a hash
+            permitted_attrs << { field_name => {} }
+          else
+            # For regular fields, check if it's the permissions_cache field which needs hash permission
+            if field_name == :permissions_cache
+              permitted_attrs << { field_name => {} }
+            else
+              permitted_attrs << field_name
+            end
+          end
+        end
+        
+        Rails.logger.debug "🔍 [ResourceLoading] Final permitted attributes: #{permitted_attrs.inspect}"
+        permitted_attrs
+      end
+
+      # Get foreign key name for belongs_to association
+      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
+
+      # Get record parameters for create/update actions
+      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
+        
+        params.require(param_key).permit(*permitted_attrs)
+      end
+
+      # Determine parameter key for field updates
+      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

data/app/controllers/easy_admin/concerns/resource_pagination.rb

@@ -0,0 +1,135 @@
+module EasyAdmin
+  module Concerns
+    # ResourcePagination concern handles pagination and related logic
+    # Provides methods for applying pagination with pagy gem
+    module ResourcePagination
+      extend ActiveSupport::Concern
+
+      private
+
+      # Apply pagination to records using Pagy
+      def apply_pagination(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_countless(records, **pagination_options)
+        else
+          pagy(records, **pagination_options)
+        end
+      end
+
+      # Setup sorting parameters with defaults
+      def setup_sorting_params
+        # Set up data needed for both HTML and turbo stream
+        # Default to id DESC if no sort params provided
+        sort_field = params[:sort] || 'id'
+        sort_direction = params[:direction] || (params[:sort] ? 'asc' : 'desc')
+        
+        [sort_field, sort_direction]
+      end
+
+      # Set current sorting state for views
+      def set_current_sorting_state(sort_field, sort_direction)
+        @current_sort_field = sort_field
+        @current_sort_direction = sort_direction
+        @current_period = params[:period]
+      end
+
+      # Build Turbo Stream response for infinite scroll
+      def build_infinite_scroll_turbo_stream
+        # 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
+
+        current_params = params.permit(:search, :scope, :sort, :direction, :period, :page, q: {})
+
+        [
+          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: current_params,
+            current_path: request.path
+          ).call),
+          turbo_stream.replace("combined-filters", EasyAdmin::CombinedFiltersComponent.new(
+            resource_class: @resource_class,
+            current_params: current_params,
+            search_params: params[:q] || {},
+            current_period: @current_period
+          ).call)
+        ]
+      end
+
+      # Prepare pagination data for index action
+      def prepare_index_pagination_data
+        sort_field, sort_direction = setup_sorting_params
+        
+        # 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
+
+        # Build filtered records
+        @records = build_filtered_records(sort_field, sort_direction)
+
+        # Apply pagination
+        @pagy, @records = apply_pagination(@records)
+
+        # Set current state for views
+        set_current_sorting_state(sort_field, sort_direction)
+      end
+
+      # Handle pagination-related parameters
+      def pagination_params
+        params.permit(:search, :scope, :sort, :direction, :period, :page, q: {})
+      end
+
+      # Check if we're on first page
+      def first_page?
+        !params[:page].present? || params[:page].to_i <= 1
+      end
+
+      # Check if pagination should reset due to filtering
+      def should_reset_pagination?
+        has_active_filters? && !first_page?
+      end
+
+      # Get pagination info for views
+      def pagination_info
+        return {} unless @pagy
+        
+        {
+          current_page: @pagy.page,
+          total_pages: @pagy.pages,
+          total_count: @pagy.count,
+          per_page: @pagy.items,
+          from: @pagy.from,
+          to: @pagy.to
+        }
+      end
+    end
+  end
+end

data/app/controllers/easy_admin/dashboard_controller.rb

@@ -1,6 +1,7 @@
 module EasyAdmin
   class DashboardController < ApplicationController
+    # Skip ActionPolicy authorization for dashboard
     def index
     end
   end
-end
+end

data/app/controllers/easy_admin/dashboards_controller.rb

@@ -7,16 +7,7 @@ module EasyAdmin
       
       respond_to do |format|
         format.html
-        format.turbo_stream do
-          render turbo_stream: turbo_stream.replace(
-            "dashboard-grid",
-            EasyAdmin::Dashboards::ShowComponent.new(
-              dashboard_class: @dashboard_class,
-              params: dashboard_params,
-              request_path: request.path
-            ).call
-          )
-        end
+        format.turbo_stream
         format.json { render json: dashboard_data }
       end
     end
@@ -33,42 +24,17 @@ module EasyAdmin
       @card_data = @dashboard_instance.card_data(@card[:name])
 
       respond_to do |format|
-        format.html do
-          render plain: EasyAdmin::Dashboards::CardStreamComponent.new(
-            card: @card,
-            card_data: @card_data,
-            dashboard_class: @dashboard_class
-          ).call
-        end
-        format.turbo_stream do
-          render turbo_stream: turbo_stream.replace(
-            "card_#{@card[:name]}",
-            EasyAdmin::Dashboards::CardStreamComponent.new(
-              card: @card,
-              card_data: @card_data,
-              dashboard_class: @dashboard_class
-            ).call
-          )
-        end
+        format.html
+        format.turbo_stream
         format.json { render json: @card_data }
       end
     rescue => e
       Rails.logger.error "Dashboard card error: #{e.message}"
+      @error_message = e.message
       
       respond_to do |format|
-        format.html do
-          render plain: view_context.turbo_frame_tag("card_#{params[:card_name]}") do
-            EasyAdmin::Dashboards::CardErrorComponent.new(error: e.message).call
-          end
-        end
-        format.turbo_stream do
-          render turbo_stream: turbo_stream.replace(
-            "card_#{params[:card_name]}",
-            view_context.turbo_frame_tag("card_#{params[:card_name]}") do
-              EasyAdmin::Dashboards::CardErrorComponent.new(error: e.message).call
-            end
-          )
-        end
+        format.html { render template: 'easy_admin/dashboards/card_error' }
+        format.turbo_stream { render template: 'easy_admin/dashboards/card_error' }
         format.json { render json: { error: e.message }, status: :server_error }
       end
     end