easy-admin-rails 0.1.15 → 0.2.0

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

@@ -0,0 +1,297 @@
+module EasyAdmin
+  module Concerns
+    # InlineFieldEditing concern handles inline field editing functionality
+    # Provides methods for editing individual fields without full form submission
+    module InlineFieldEditing
+      extend ActiveSupport::Concern
+
+      # Field editing actions
+      def edit_field
+        @field_name = params[:field]
+        @field_config = find_field_config_by_name_or_association(@field_name)
+        
+        unless @field_config
+          render json: { error: "Field '#{@field_name}' not found" }, status: :not_found
+          return
+        end
+
+        respond_to do |format|
+          format.html { render template: 'easy_admin/resources/edit_field', layout: false }
+          format.turbo_stream { render template: 'easy_admin/resources/edit_field' }
+        end
+      end
+
+      def update_field
+        @field_name = params[:field]
+        @field_config = find_field_config_by_name_or_association(@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
+          update_attrs = build_belongs_to_update_attributes(param_key)
+        else
+          update_attrs = build_regular_field_update_attributes(param_key)
+        end
+
+        if @record.update(update_attrs)
+          handle_successful_field_update
+        else
+          handle_failed_field_update
+        end
+      end
+
+      # Get autocomplete suggestions for fields
+      def suggest
+        # Try to find field by name first, then by association name
+        field_config = @resource_class.fields_config.find { |f| f[:name].to_s == params[:field] }
+        
+        # If not found by field name, try to find by association name
+        if !field_config
+          field_config = @resource_class.fields_config.find { |f| f[:association].to_s == params[:field] }
+        end
+        
+        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
+
+      # Helper method to find field config by name or association name
+      def find_field_config_by_name_or_association(field_identifier)
+        # Try to find field by name first
+        field_config = find_field_config(field_identifier)
+        
+        # If not found by field name, try to find by association name
+        if !field_config
+          field_config = @resource_class.fields_config.find { |f| f[:association].to_s == field_identifier }
+        end
+        
+        field_config
+      end
+
+      # Build update attributes for belongs_to fields
+      def build_belongs_to_update_attributes(param_key)
+        association_name = @field_config[:name]
+        foreign_key = get_foreign_key_name(association_name)
+        field_value = params.dig(param_key, foreign_key)
+        { foreign_key.to_sym => field_value }
+      end
+
+      # Build update attributes for regular fields
+      def build_regular_field_update_attributes(param_key)
+        # 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)
+        update_attrs
+      end
+
+      # Handle successful field update response
+      def handle_successful_field_update
+        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_config[: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
+      end
+
+      # Handle failed field update response
+      def handle_failed_field_update
+        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
+
+      # Get suggestion options for field autocomplete
+      def get_suggest_options(field_config, search_term, limit)
+        # Handle different field types that support suggest
+        case field_config[:type]
+        when :belongs_to
+          association_name = field_config[:association] || field_config[:name]
+          get_belongs_to_suggest_options(association_name, field_config, search_term, limit)
+        when :has_many
+          association_name = field_config[:association] || field_config[:name]
+          get_has_many_suggest_options(association_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
+
+      # Get suggestion options for belongs_to fields
+      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
+
+      # Get suggestion options for has_many fields
+      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
+
+      # Get suggestion options for static select fields
+      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
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module EasyAdmin
+  module Concerns
+    # ResourceAuthorization concern handles authorization checks for resource actions
+    # Provides before_action callbacks and authorization methods for all CRUD operations
+    module ResourceAuthorization
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :authorize_resource_access!, only: [:index]
+        before_action :authorize_record_access!, only: [:show]
+        before_action :authorize_record_creation!, only: [:new, :create]
+        before_action :authorize_record_update!, only: [
+          :edit, :update, :edit_field, :update_field, 
+          :belongs_to_reattach, :belongs_to_edit_attached, :update_belongs_to_attached
+        ]
+        before_action :authorize_record_destruction!, only: [:destroy]
+        before_action :authorize_versioning_access!, only: [:versions, :revert_version, :version_diff]
+      end
+
+      private
+
+      # Authorize access to resource index
+      def authorize_resource_access!
+        authorize! @resource_class.model_class, to: :index?
+      end
+      
+      # Authorize access to view a specific record
+      def authorize_record_access!
+        authorize! @record, to: :show?
+      end
+      
+      # Authorize creation of new records
+      def authorize_record_creation!
+        authorize! @resource_class.model_class, to: :create?
+      end
+      
+      # Authorize updating of existing records
+      def authorize_record_update!
+        authorize! @record, to: :update?
+      end
+      
+      # Authorize destruction of existing records
+      def authorize_record_destruction!
+        authorize! @record, to: :destroy?
+      end
+      
+      # Authorize access to versioning features (PaperTrail integration)
+      def authorize_versioning_access!
+        # Check if user can view record and has versioning permissions
+        authorize! @record, to: :show?
+        authorize! @record, to: :manage_versions?
+      end
+    end
+  end
+end

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