easy-admin-rails 0.1.0

data/app/controllers/easy_admin/row_actions_controller.rb

@@ -0,0 +1,216 @@
+module EasyAdmin
+  class RowActionsController < ApplicationController
+    before_action :load_resource_class
+    before_action :load_record
+    before_action :load_action_class, only: [:execute, :form]
+    
+    # Render context menu with available actions
+    def context_menu
+      available_actions = @resource_class.row_actions.map do |action_config|
+        action_instance = action_config[:class].new(
+          record: @record,
+          current_user: current_admin_user,
+          resource_class: @resource_class
+        )
+        
+        next unless action_instance.visible? && action_instance.permitted?
+        
+        {
+          class: action_config[:class],
+          instance: action_instance
+        }
+      end.compact
+      
+      respond_to do |format|
+        format.turbo_stream do
+          render turbo_stream: turbo_stream.update(
+            "context-menu-#{@record.id}",
+            EasyAdmin::ContextMenuComponent.new(
+              record: @record,
+              resource_class: @resource_class,
+              actions: available_actions
+            ).call
+          )
+        end
+      end
+    end
+    
+    # Execute an action
+    def execute
+      action_instance = @action_class.new(
+        record: @record,
+        current_user: current_admin_user,
+        resource_class: @resource_class,
+        params: row_action_params.to_h
+      )
+      
+      unless action_instance.permitted?
+        head :forbidden
+        return
+      end
+      
+      result = action_instance.perform
+      
+      respond_to do |format|
+        format.turbo_stream do
+          streams = build_turbo_response(action_instance, result)
+          
+          # Add notification if message provided
+          if result[:message]
+            streams << turbo_stream.update(
+              "notifications",
+              EasyAdmin::NotificationComponent.new(
+                message: result[:message],
+                type: result[:success] ? :success : :error
+              ).call
+            )
+          end
+          
+          render turbo_stream: streams
+        end
+      end
+    rescue => e
+      Rails.logger.error "Row action execution failed: #{e.message}"
+      Rails.logger.error e.backtrace.join("\n")
+      
+      respond_to do |format|
+        format.turbo_stream do
+          render turbo_stream: turbo_stream.update(
+            "notifications",
+            EasyAdmin::NotificationComponent.new(
+              message: "Action failed: #{e.message}",
+              type: :error
+            ).call
+          )
+        end
+      end
+    end
+    
+    # Render form for modal actions
+    def form
+      action_instance = @action_class.new(
+        record: @record,
+        current_user: current_admin_user,
+        resource_class: @resource_class
+      )
+      
+      unless action_instance.permitted?
+        head :forbidden
+        return
+      end
+      
+      respond_to do |format|
+        format.turbo_stream do
+          render turbo_stream: turbo_stream.update(
+            "modal",
+            EasyAdmin::RowActionFormComponent.new(
+              record: @record,
+              action_class: @action_class,
+              resource_class: @resource_class,
+              submit_url: easy_admin.row_action_path(
+                @resource_class.route_key,
+                @record,
+                action_class: params[:action_class]
+              )
+            ).call
+          )
+        end
+      end
+    end
+    
+    private
+    
+    def load_resource_class
+      resource_name = params[:resource_name]
+      @resource_class = EasyAdmin::ResourceRegistry.find_resource(resource_name)
+      
+      unless @resource_class
+        raise ActiveRecord::RecordNotFound, "Resource #{resource_name} not found"
+      end
+    end
+    
+    def load_record
+      @record = @resource_class.model_class.find(params[:id])
+    end
+    
+    def load_action_class
+      action_class_name = params[:action_class]
+      
+      # Check if it's a built-in EasyAdmin action
+      if action_class_name.start_with?('EasyAdmin::')
+        begin
+          @action_class = action_class_name.constantize
+          return
+        rescue NameError
+          # Fall through to resource-specific actions
+        end
+      end
+      
+      # Find action in resource configuration
+      action_config = @resource_class.row_actions.find do |config|
+        config[:class].name == action_class_name
+      end
+      
+      unless action_config
+        raise ActiveRecord::RecordNotFound, "Action #{action_class_name} not found"
+      end
+      
+      @action_class = action_config[:class]
+    end
+    
+    def row_action_params
+      # Return empty hash if no row_action params (for instant actions)
+      return {} unless params[:row_action].present?
+      
+      # Allow action-specific parameters based on action class attributes
+      if @action_class.respond_to?(:attribute_types)
+        permitted_attrs = @action_class.attribute_types.keys.map(&:to_sym) - [:record, :current_user, :resource_class, :params]
+        params.require(:row_action).permit(*permitted_attrs)
+      else
+        params.fetch(:row_action, {}).permit!
+      end
+    end
+    
+    def build_turbo_response(action_instance, result)
+      strategy = result[:strategy] || action_instance.turbo_response_strategy
+      
+      streams = []
+      
+      case strategy
+      when :replace
+        streams << turbo_stream.replace(
+          helpers.dom_id(@record),
+          EasyAdmin::Resources::TableRowComponent.new(
+            record: @record.reload,
+            resource_class: @resource_class
+          ).call
+        )
+      when :remove
+        streams << turbo_stream.remove(helpers.dom_id(@record))
+      when :update
+        # Update with visual changes
+        updated_row = EasyAdmin::Resources::TableRowComponent.new(
+          record: @record.reload,
+          resource_class: @resource_class
+        )
+        
+        streams << turbo_stream.replace(helpers.dom_id(@record), updated_row.call)
+      when :refresh
+        # Refresh the entire table
+        streams << turbo_stream.replace(
+          "table-frame",
+          turbo_frame_tag("table-frame", src: easy_admin.resources_path(@resource_class.route_key))
+        )
+      end
+      
+      # Handle redirect if specified
+      if result[:redirect_to]
+        streams << turbo_stream.append("body", 
+          "<script>window.location.href = '#{result[:redirect_to]}';</script>".html_safe
+        )
+      end
+      
+      streams
+    end
+  end
+end

data/app/controllers/easy_admin/sessions_controller.rb

@@ -0,0 +1,32 @@
+module EasyAdmin
+  class SessionsController < Devise::SessionsController
+    layout 'easy_admin/auth'
+    
+    # GET /easy_admin/sign_in
+    def new
+      super
+    end
+
+    # POST /easy_admin/sign_in
+    def create
+      super
+    end
+
+    # DELETE /easy_admin/sign_out
+    def destroy
+      super
+    end
+
+    protected
+
+    # The path used after signing in
+    def after_sign_in_path_for(resource)
+      easy_admin.root_path
+    end
+
+    # The path used after signing out
+    def after_sign_out_path_for(resource_or_scope)
+      new_admin_user_session_path
+    end
+  end
+end

data/app/controllers/easy_admin/settings_controller.rb

@@ -0,0 +1,94 @@
+module EasyAdmin
+  class SettingsController < ApplicationController
+    before_action :ensure_settings_enabled
+
+    def index
+      @feature_toggles = get_feature_toggles
+    end
+
+    def update
+      params[:features]&.each do |feature_name, enabled|
+        if enabled == "1"
+          Flipper.enable(feature_name)
+        else
+          Flipper.disable(feature_name)
+        end
+      end
+
+      # Refresh the feature toggles for the turbo frame response
+      @feature_toggles = get_feature_toggles
+      
+      respond_to do |format|
+        format.html { redirect_to settings_path, notice: "Feature toggles updated successfully" }
+        format.turbo_stream { 
+          render turbo_stream: turbo_stream.replace(
+            "settings-sidebar", 
+            EasyAdmin::SettingsSidebarComponent.new(feature_toggles: @feature_toggles, expanded: true).call
+          )
+        }
+      end
+    end
+
+    private
+
+    def get_feature_toggles
+      # Return all registered features with their current state
+      Flipper.features.map do |feature|
+        {
+          name: feature.name,
+          enabled: feature.enabled?,
+          description: feature_description(feature.name)
+        }
+      end
+    end
+
+    def ensure_settings_enabled
+      unless EasyAdmin.configuration.global_settings && defined?(Flipper)
+        redirect_to root_path, alert: "Settings are not available"
+      end
+    end
+
+    def feature_description(feature_name)
+      # You can customize descriptions for your features here
+      descriptions = {
+        # UI & Design Features
+        "new_ui" => "Enable the new user interface design",
+        "dark_mode" => "Switch to dark theme across the admin panel",
+        "compact_layout" => "Use a more compact layout to fit more content",
+        
+        # Search & Filtering Features  
+        "advanced_search" => "Enable advanced search with multiple filters",
+        "fuzzy_search" => "Allow approximate text matching in search",
+        "search_suggestions" => "Show suggested search terms as you type",
+        
+        # Performance Features
+        "infinite_scroll" => "Load more content automatically when scrolling",
+        "lazy_loading" => "Load images and content only when needed",
+        "cache_optimization" => "Improve page load times with advanced caching",
+        
+        # Beta & Experimental Features
+        "beta_features" => "Access to experimental features and improvements",
+        "ai_suggestions" => "Get AI-powered suggestions and recommendations",
+        "real_time_updates" => "See live updates without refreshing the page",
+        
+        # Analytics & Monitoring
+        "detailed_analytics" => "View comprehensive analytics and reports",
+        "performance_monitoring" => "Monitor system performance and metrics",
+        "user_tracking" => "Track user behavior and interaction patterns",
+        
+        # Export & Integration Features
+        "csv_export" => "Export data to CSV format for external use",
+        "pdf_export" => "Generate PDF reports and documents",
+        "api_access" => "Enable REST API access for integrations",
+        "webhook_notifications" => "Send real-time notifications via webhooks",
+        
+        # Admin Features
+        "admin_logs" => "Keep detailed logs of all admin activities",
+        "audit_trail" => "Maintain a complete audit trail of changes",
+        "bulk_operations" => "Perform operations on multiple items at once"
+      }
+      
+      descriptions[feature_name.to_s] || "Toggle #{feature_name.humanize.downcase}"
+    end
+  end
+end

data/app/helpers/easy_admin/application_helper.rb

@@ -0,0 +1,4 @@
+module EasyAdmin
+  module ApplicationHelper
+  end
+end

data/app/helpers/easy_admin/dashboards_helper.rb

@@ -0,0 +1,121 @@
+module EasyAdmin
+  module DashboardsHelper
+    def render_card(card, dashboard_class, request_params = nil)
+      component_class = card_component_class(card[:type])
+      
+      # Use provided params or try to access from context
+      permitted_params = if request_params
+        request_params.permit(:date_from, :date_to, :segment, :search, :period, :refresh)
+      elsif respond_to?(:params)
+        params.permit(:date_from, :date_to, :segment, :search, :period, :refresh)
+      else
+        {}
+      end
+      
+      component = component_class.new(
+        card: card,
+        dashboard_class: dashboard_class,
+        request_params: permitted_params
+      )
+    end
+
+    # Metric card helper methods
+    def metric_value_classes
+      base_classes = "text-3xl font-bold mb-1"
+      if @card_data[:delta]
+        case trend_direction
+        when :positive
+          "#{base_classes} text-green-600"
+        when :negative  
+          "#{base_classes} text-red-600"
+        else
+          "#{base_classes} text-gray-900"
+        end
+      else
+        "#{base_classes} text-gray-900"
+      end
+    end
+    
+    def trend_indicator_classes
+      base_classes = "flex items-center justify-center w-10 h-10 rounded-full"
+      case trend_direction
+      when :positive
+        "#{base_classes} bg-green-100 text-green-600"
+      when :negative
+        "#{base_classes} bg-red-100 text-red-600" 
+      else
+        "#{base_classes} bg-gray-100 text-gray-600"
+      end
+    end
+    
+    def delta_badge_classes
+      base_classes = "inline-flex items-center px-2 py-1 rounded-full text-xs font-medium"
+      case trend_direction
+      when :positive
+        "#{base_classes} bg-green-100 text-green-800"
+      when :negative
+        "#{base_classes} bg-red-100 text-red-800"
+      else
+        "#{base_classes} bg-gray-100 text-gray-600" 
+      end
+    end
+    
+    def trend_direction
+      return :neutral unless @card_data[:delta]
+      @card_data[:delta].to_f > 0 ? :positive : (@card_data[:delta].to_f < 0 ? :negative : :neutral)
+    end
+    
+    def trend_icon
+      case trend_direction
+      when :positive
+        "↗"
+      when :negative
+        "↘"
+      else
+        "→"
+      end
+    end
+    
+    def sparkline_color
+      case trend_direction
+      when :positive
+        "#059669" # green-600
+      when :negative
+        "#dc2626" # red-600
+      else
+        "#4f46e5" # indigo-600
+      end
+    end
+    
+    def sparkline_points
+      return "" unless @card_data[:sparkline_data]&.any?
+      
+      data = @card_data[:sparkline_data]
+      max_val = data.map { |d| d[:value] }.max
+      min_val = data.map { |d| d[:value] }.min
+      range = max_val - min_val
+      range = 1 if range == 0
+      
+      data.map.with_index do |point, i|
+        x = i * (100.0 / (data.length - 1))
+        y = 25 - ((point[:value] - min_val) / range.to_f * 20)
+        "#{x},#{y}"
+      end.join(' ')
+    end
+
+    private
+
+    def card_component_class(card_type)
+      case card_type.to_sym
+      when :metric
+        EasyAdmin::Dashboards::MetricCardComponent
+      when :chart
+        EasyAdmin::Dashboards::ChartCardComponent
+      when :table
+        EasyAdmin::Dashboards::TableCardComponent
+      else
+        EasyAdmin::Dashboards::BaseCardComponent
+      end
+    end
+  end
+end

data/app/helpers/easy_admin/fields_helper.rb

@@ -0,0 +1,27 @@
+module EasyAdmin
+  module FieldsHelper
+    def render_field(field, action:, value: nil, record: nil, form: nil)
+      component = EasyAdmin::Field.render(
+        field[:type], 
+        action: action,
+        field: field,
+        value: value,
+        record: record,
+        form: form
+      )
+
+      component.call.html_safe
+    end
+
+    def field_component(field, action:, value: nil, record: nil, form: nil)
+      EasyAdmin::Field.render(
+        field[:type], 
+        action: action,
+        field: field,
+        value: value,
+        record: record,
+        form: form
+      )
+    end
+  end
+end

data/app/helpers/easy_admin/pagy_helper.rb

@@ -0,0 +1,30 @@
+module EasyAdmin
+  module PagyHelper
+    include Pagy::Frontend
+
+    # Override Pagy's default nav method to use our custom component
+    def pagy_nav(pagy, pagy_id: nil, link_extra: '', **vars)
+      EasyAdmin::PaginationComponent.new(pagy: pagy).call.html_safe
+    end
+
+    # iOS-style pagination info
+    def pagy_info(pagy, **vars)
+      return '' if pagy.count == 0
+      
+      from, to, count = pagy.from, pagy.to, pagy.count
+      
+      if count == 1
+        "Showing 1 result"
+      elsif from == to
+        "Showing result #{from} of #{count}"
+      else
+        "Showing #{from} to #{to} of #{count} results"
+      end
+    end
+
+    # Compact pagination info for mobile
+    def pagy_info_compact(pagy, **vars)
+      "#{pagy.page} of #{pagy.pages}"
+    end
+  end
+end

data/app/helpers/easy_admin/resources_helper.rb

@@ -0,0 +1,39 @@
+module EasyAdmin
+  module ResourcesHelper
+    def sort_link(field, label = nil)
+      label ||= field[:label]
+      field_name = field[:name]
+      
+      # Determine current sort direction and next direction
+      is_active = @current_sort_field == field_name.to_s
+      current_direction = @current_sort_direction if is_active
+      next_direction = is_active && current_direction == 'asc' ? 'desc' : 'asc'
+      
+      # Build URL parameters
+      params_hash = params.permit(:search).to_h
+      params_hash[:sort] = field_name
+      params_hash[:direction] = next_direction
+      
+      css_class = "ea-sort-pill"
+      css_class += " ea-sort-pill--active" if is_active
+      
+      link_to easy_admin.resources_path(@resource_class.route_key, params_hash), 
+              class: css_class do
+        content = label.dup
+        if is_active
+          content += " #{current_direction == 'asc' ? '↑' : '↓'}"
+        end
+        content.html_safe
+      end
+    end
+    
+    def sort_arrow_svg
+      <<~SVG.html_safe
+        <svg width="8" height="12" viewBox="0 0 8 12" fill="none" class="ea-sort-arrow-icon">
+          <path d="M4 1L1 4H7L4 1Z" fill="currentColor" class="ea-sort-up"/>
+          <path d="M4 11L7 8H1L4 11Z" fill="currentColor" class="ea-sort-down"/>
+        </svg>
+      SVG
+    end
+  end
+end

data/app/javascript/easy_admin/application.js

@@ -0,0 +1,12 @@
+import { Application } from "@hotwired/stimulus"
+
+// Start the Stimulus application
+const application = Application.start()
+
+// Configure debug mode
+application.debug = window?.localStorage.getItem('easy_admin.debug') === 'true'
+
+// Set global Stimulus reference
+window.Stimulus = application
+
+export { application }

data/app/javascript/easy_admin/controllers/batch_modal_controller.js

@@ -0,0 +1,66 @@
+import { Controller } from "@hotwired/stimulus"
+import { post } from "@rails/request.js"
+
+export default class extends Controller {
+  static targets = ["form"]
+  static values = { 
+    submitUrl: String,
+    selectedIds: String,
+    actionClass: String 
+  }
+  
+  close() {
+    this.element.remove()
+  }
+  
+  submit() {
+    const formData = this.collectFormData()
+    
+    post(this.submitUrlValue, {
+      body: formData,
+      responseKind: 'turbo-stream'
+    }).then(response => {
+      if (response.ok) {
+        // Dispatch event to clear selection
+        window.dispatchEvent(new CustomEvent('batch-action:completed'))
+        this.close()
+      }
+    }).catch(error => {
+      console.error('Batch action submission failed:', error)
+    })
+  }
+  
+  collectFormData() {
+    const formData = new FormData()
+    
+    // Add CSRF token
+    const csrfToken = document.querySelector('[name="csrf-token"]').content
+    formData.append('authenticity_token', csrfToken)
+    
+    // Add action class and execution mode
+    formData.append('action_class', this.actionClassValue)
+    formData.append('execution_mode', 'modal')
+    
+    // Add selected IDs
+    this.selectedIdsValue.split(',').forEach(id => {
+      formData.append('selected_ids[]', id)
+    })
+    
+    // Collect form field data from the rendered form components
+    const formElement = this.formTarget
+    const inputs = formElement.querySelectorAll('input, select, textarea')
+    
+    inputs.forEach(input => {
+      const name = input.name
+      if (name && name.startsWith('batch_action[')) {
+        if (input.type === 'checkbox') {
+          formData.append(name, input.checked ? '1' : '0')
+        } else {
+          formData.append(name, input.value || '')
+        }
+      }
+    })
+    
+    return formData
+  }
+}