easy-admin-rails 0.1.0

data/app/components/easy_admin/sidebar_component.rb

@@ -0,0 +1,174 @@
+module EasyAdmin
+  class SidebarComponent < Phlex::HTML
+    def initialize(items: nil, current_path: nil)
+      @items = items || EasyAdmin.configuration.sidebar_items
+      @current_path = current_path
+    end
+
+    def view_template
+      div(data: { controller: "sidebar-mobile" }) do
+        # Sidebar overlay for mobile
+        div(
+          class: "fixed inset-0 z-40 lg:hidden bg-gray-600 bg-opacity-75 transition-opacity duration-300 opacity-0 pointer-events-none sidebar-overlay",
+          data: {
+            sidebar_target: "overlay",
+            sidebar_mobile_target: "overlay",
+            action: "click->sidebar-mobile#close click->sidebar#close"
+          }
+        )
+
+        # Sidebar container
+        aside(
+          class: "fixed inset-y-0 left-0 z-50 w-64 bg-white border-r border-gray-200 transform transition-transform duration-300 -translate-x-full lg:translate-x-0 shadow-lg sidebar",
+          data: {
+            sidebar_target: "container",
+            sidebar_mobile_target: "container",
+            controller: "sidebar-nav"
+          }
+        ) do
+          # Header with logo and brand
+          div(class: "flex items-center justify-between px-6 py-4 border-b border-gray-200 bg-gradient-to-r from-blue-600 to-blue-700 transition-all duration-300") do
+            # Logo container - centers when collapsed
+            div(class: "flex items-center space-x-3 transition-all duration-300 sidebar-logo-container") do
+              div(class: "min-w-[2.5rem] w-10 h-10 bg-white rounded-lg flex items-center justify-center flex-shrink-0 sidebar-logo") do
+                span(class: "text-blue-600 font-bold text-xl") { "EA" }
+              end
+              # App name - hidden when collapsed
+              h2(class: "text-white font-semibold text-lg hidden lg:block transition-opacity duration-300 sidebar-app-name") do
+                EasyAdmin.configuration.app_name
+              end
+            end
+
+            # Mobile close button
+            button(
+              class: "lg:hidden p-1 rounded-md text-white hover:bg-blue-800 transition-colors",
+              data: { action: "click->sidebar#toggle" }
+            ) do
+              unsafe_raw('<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path></svg>')
+            end
+          end
+
+          # Navigation menu
+          nav(class: "flex-1 px-4 py-6 overflow-y-auto") do
+            ul(class: "space-y-2") do
+              @items.each do |item|
+                render_sidebar_item(item)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def render_sidebar_item(item)
+      li do
+        if item[:children]&.any?
+          render_expandable_item(item)
+        else
+          render_simple_item(item)
+        end
+      end
+    end
+
+    def render_simple_item(item)
+      active_classes = is_active?(item) ? "bg-blue-50 text-blue-700 border-r-2 border-blue-600" : "text-gray-700 hover:bg-gray-50 hover:text-gray-900"
+
+      a(
+        href: item[:path],
+        class: "group flex items-center px-3 py-2.5 text-sm font-medium rounded-md transition-colors duration-200 #{active_classes}"
+      ) do
+        # Icon
+        if item[:icon]
+          span(class: "flex-shrink-0 min-w-[1.5rem] w-6 mr-3 text-lg flex items-center justify-center") { item[:icon] }
+        end
+        # Label
+        span(class: "truncate") { item[:label] }
+      end
+    end
+
+    def render_expandable_item(item)
+      has_active_child = has_active_child?(item)
+      active_classes = has_active_child ? "bg-blue-50 text-blue-700" : "text-gray-700 hover:bg-gray-50 hover:text-gray-900"
+
+      div(class: "space-y-1") do
+        # Expandable button
+        button(
+          class: "group w-full flex items-center justify-between px-3 py-2.5 text-sm font-medium rounded-md transition-colors duration-200 #{active_classes}",
+          data: {
+            action: "click->sidebar-nav#toggle",
+            sidebar_nav_target: "toggle"
+          }
+        ) do
+          # Icon and Label container
+          div(class: "flex items-center") do
+            # Icon
+            if item[:icon]
+              span(class: "flex-shrink-0 min-w-[1.5rem] w-6 mr-3 text-lg flex items-center justify-center") { item[:icon] }
+            end
+            # Label
+            span(class: "text-left truncate") { item[:label] }
+          end
+
+          # Chevron
+          unsafe_raw(%(<svg class="h-5 w-5 transform transition-transform duration-200 #{'rotate-90' if has_active_child}" fill="none" stroke="currentColor" viewBox="0 0 24 24" data-sidebar-nav-target="chevron"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5l7 7-7 7"></path></svg>))
+        end
+
+        # Submenu
+        div(
+          class: "space-y-1 #{'block' if has_active_child} #{'hidden' unless has_active_child}",
+          data: { sidebar_nav_target: "submenu" }
+        ) do
+          item[:children].each do |child|
+            render_submenu_item(child)
+          end
+        end
+      end
+    end
+
+    def render_submenu_item(item)
+      active_classes = is_active?(item) ? "bg-blue-50 text-blue-700 border-r-2 border-blue-600" : "text-gray-600 hover:bg-gray-50 hover:text-gray-900"
+
+      a(
+        href: item[:path],
+        class: "group flex items-center px-6 py-2 text-sm font-medium rounded-md transition-colors duration-200 #{active_classes}"
+      ) do
+        # Icon (smaller for submenu items)
+        if item[:icon]
+          span(class: "flex-shrink-0 min-w-[1.25rem] w-5 mr-2 text-sm flex items-center justify-center") { item[:icon] }
+        end
+        # Label
+        span(class: "truncate") { item[:label] }
+      end
+    end
+
+    # Helper methods for determining active state
+    def is_active?(item)
+      return false unless @current_path && item[:path]
+
+      # Exact match
+      return true if @current_path == item[:path]
+
+      # Check if current path starts with item path (for nested routes)
+      # But avoid matching root path "/" with everything
+      if item[:path] != "/" && @current_path.start_with?(item[:path])
+        return true
+      end
+
+      false
+    end
+
+    def has_active_child?(item)
+      return false unless item[:children]
+
+      item[:children].any? do |child|
+        if child[:children]
+          has_active_child?(child)
+        else
+          is_active?(child)
+        end
+      end
+    end
+  end
+end

data/app/components/easy_admin/turbo/response_component.rb

@@ -0,0 +1,40 @@
+module EasyAdmin
+  module Turbo
+    class ResponseComponent < BaseComponent
+      def initialize(&block)
+        @builder = block
+      end
+
+      def view_template
+        # The builder receives a small DSL via `yield self`
+        @builder&.call(self)
+      end
+
+      # --- Actions API (return component instances, not html_safe strings) ---
+      def replace(target, **attrs, &block)
+        render StreamComponent.new(action: "replace", target: target, **attrs, &block)
+      end
+
+      def append(target, **attrs, &block)
+        render StreamComponent.new(action: "append", target: target, **attrs, &block)
+      end
+
+      def prepend(target, **attrs, &block)
+        render StreamComponent.new(action: "prepend", target: target, **attrs, &block)
+      end
+
+      def remove(target, **attrs)
+        render StreamComponent.new(action: "remove", target: target, **attrs)
+      end
+
+      def update(target, **attrs, &block)
+        render StreamComponent.new(action: "update", target: target, **attrs, &block)
+      end
+
+      # Custom action: requires Turbo.StreamActions.redirect in JS
+      def redirect_to(url)
+        render StreamComponent.new(action: "redirect", url: url)
+      end
+    end
+  end
+end

data/app/components/easy_admin/turbo/stream_component.rb

@@ -0,0 +1,28 @@
+module EasyAdmin
+  module Turbo
+    class StreamComponent < BaseComponent
+      def initialize(action:, target: nil, targets: nil, **attrs, &block)
+        @action = action
+        @target = target
+        @targets = targets
+        @attrs = attrs
+        @block = block
+      end
+
+      def view_template
+        attrs = { action: @action }.merge(@attrs)
+        attrs[:target] = @target if @target
+        attrs[:targets] = @targets if @targets
+
+        turbo_stream(**attrs) do
+          if @block
+            template do
+              # Yield the block so callers can `render` nested components
+              @block.call(self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/easy_admin/application_controller.rb

@@ -0,0 +1,66 @@
+module EasyAdmin
+  class ApplicationController < ActionController::Base
+    include Pagy::Backend
+    
+    helper EasyAdmin::FieldsHelper
+    helper EasyAdmin::PagyHelper
+    
+    before_action :authenticate_easy_admin_admin_user!
+    before_action :set_active_storage_url_options
+    before_action :set_feature_toggles
+    
+    protected
+    
+    def authenticate_easy_admin_admin_user!
+      authenticate_admin_user! || redirect_to_sign_in
+    end
+    
+    private
+    
+    def authenticate_admin_user!
+      return true if admin_user_signed_in?
+      false
+    end
+    
+    def admin_user_signed_in?
+      !!current_admin_user
+    end
+    
+    def current_admin_user
+      @current_admin_user ||= warden.authenticate(scope: :admin_user)
+    end
+    
+    def redirect_to_sign_in
+      redirect_to new_admin_user_session_path, alert: 'You need to sign in to access this page.'
+    end
+    
+    def set_active_storage_url_options
+      ActiveStorage::Current.url_options = { host: request.base_url } if defined?(ActiveStorage::Current)
+    end
+    
+    def set_feature_toggles
+      return unless EasyAdmin.configuration.global_settings && defined?(Flipper)
+      
+      @feature_toggles = Flipper.features.map do |feature|
+        {
+          name: feature.name,
+          enabled: feature.enabled?,
+          description: feature_description(feature.name)
+        }
+      end
+    end
+    
+    def feature_description(feature_name)
+      descriptions = {
+        "new_ui" => "Enable the new user interface design",
+        "advanced_search" => "Enable advanced search functionality",
+        "dark_mode" => "Enable dark mode theme",
+        "beta_features" => "Enable beta features for testing"
+      }
+      
+      descriptions[feature_name.to_s] || "Toggle #{feature_name.humanize.downcase}"
+    end
+    
+    helper_method :current_admin_user, :admin_user_signed_in?
+  end
+end

data/app/controllers/easy_admin/batch_actions_controller.rb

@@ -0,0 +1,166 @@
+module EasyAdmin
+  class BatchActionsController < ApplicationController
+    before_action :set_resource_class
+    before_action :set_selected_records, only: [:execute, :form]
+    
+    def execute
+      action_class_name = params[:action_class]
+      execution_mode = params[:execution_mode]
+      
+      begin
+        action_class = action_class_name.constantize
+        action_instance = action_class.new
+        
+        # Set attributes for modal actions
+        if execution_mode == 'modal'
+          action_instance.assign_attributes(batch_action_params(action_class))
+          
+          unless action_instance.valid?
+            respond_to do |format|
+              format.turbo_stream do
+                render turbo_stream: [
+                  turbo_stream.update("notifications",
+                    EasyAdmin::NotificationComponent.new(
+                      type: :error,
+                      message: action_instance.errors.full_messages.join(', '),
+                      title: "Validation Error"
+                    ).call
+                  ),
+                ]
+              end
+            end
+            return
+          end
+        end
+        
+        # Set up the action instance with selected records and current user
+        action_instance.selected_ids = @selected_records.pluck(:id)
+        action_instance.current_user = current_admin_user
+        action_instance.resource_class = @resource_class
+        action_instance.params = batch_action_params(action_class).to_h
+        # Execute the batch action
+        result = action_instance.perform
+        
+        respond_to do |format|
+          format.turbo_stream do
+            if result[:success]
+              # Update each affected row individually
+              streams = [
+                turbo_stream.update("notifications",
+                  EasyAdmin::NotificationComponent.new(
+                    type: :success,
+                    message: result[:message] || 'Action completed successfully',
+                    title: "Success"
+                  ).call
+                )
+              ]
+              
+              # Add individual row updates
+              @selected_records.each do |record|
+                # Reload record to get updated data
+                record.reload
+                streams << turbo_stream.replace(
+                  helpers.dom_id(record),
+                  EasyAdmin::Resources::TableRowComponent.new(
+                    record: record,
+                    resource_class: @resource_class
+                  ).call
+                )
+              end
+              
+              render turbo_stream: streams
+            else
+              render turbo_stream: [
+                turbo_stream.update("notifications",
+                  EasyAdmin::NotificationComponent.new(
+                    type: :error,
+                    message: result[:message] || 'Action failed',
+                    title: "Error"
+                  ).call
+                ),
+              ]
+            end
+          end
+        end
+        
+      rescue NameError => e
+        Rails.logger.error e.backtrace
+        respond_to do |format|
+          format.turbo_stream do
+            render turbo_stream: turbo_stream.update("notifications",
+              EasyAdmin::NotificationComponent.new(
+                type: :error,
+                message: 'Invalid action class',
+                title: "Error"
+              ).call
+            )
+          end
+        end
+      end
+    end
+    
+    def form
+      action_class_name = params[:action_class]
+      selected_ids = params[:selected_ids]&.split(',') || []
+      
+      begin
+        action_class = action_class_name.constantize
+        
+        respond_to do |format|
+          format.turbo_stream do
+            render turbo_stream: turbo_stream.update(
+              'modal',
+              render_batch_action_form(action_class, selected_ids).call
+            )
+          end
+        end
+        
+      rescue NameError
+        respond_to do |format|
+          format.turbo_stream do
+            render turbo_stream: turbo_stream.update("notifications",
+              EasyAdmin::NotificationComponent.new(
+                type: :error,
+                message: 'Invalid action class',
+                title: "Error"
+              ).call
+            )
+          end
+        end
+      end
+    end
+    
+    private
+    
+    def set_resource_class
+      @resource_class = EasyAdmin::ResourceRegistry.find_resource(params[:resource_name])
+    end
+    
+    def set_selected_records
+      selected_ids = params[:selected_ids]
+      selected_ids = selected_ids.split(',') if selected_ids.is_a?(String)
+      selected_ids = selected_ids || []
+      
+      @selected_records = @resource_class.model_class.where(id: selected_ids)
+    end
+    
+    def batch_action_params(action_class)
+      return {} unless params[:batch_action].present?
+      
+      # Get the allowed parameters from the action class
+      allowed_params = action_class.attribute_names
+      params.require(:batch_action).permit(allowed_params)
+    end
+    
+    def render_batch_action_form(action_class, selected_ids)
+      submit_url = "/admin/#{@resource_class.route_key}/batch_action"
+      EasyAdmin::BatchActionFormComponent.new(
+        resource_class: @resource_class,
+        action_class: action_class,
+        selected_records: @selected_records,
+        selected_ids: selected_ids,
+        submit_url: submit_url
+      )
+    end
+  end
+end

data/app/controllers/easy_admin/confirmation_modal_controller.rb

@@ -0,0 +1,20 @@
+module EasyAdmin
+  class ConfirmationModalController < ApplicationController
+    def show
+      respond_to do |format|
+        format.turbo_stream do
+          render turbo_stream: turbo_stream.update(
+            "modal",
+            EasyAdmin::ConfirmationModalComponent.new(
+              title: params[:title] || "Confirm",
+              message: params[:message] || "Are you sure?",
+              confirm_text: params[:confirm_text] || "Confirm",
+              cancel_text: params[:cancel_text] || "Cancel",
+              danger: params[:danger] == "true"
+            ).call
+          )
+        end
+      end
+    end
+  end
+end

data/app/controllers/easy_admin/dashboard_controller.rb

@@ -0,0 +1,6 @@
+module EasyAdmin
+  class DashboardController < ApplicationController
+    def index
+    end
+  end
+end

data/app/controllers/easy_admin/dashboards_controller.rb

@@ -0,0 +1,123 @@
+module EasyAdmin
+  class DashboardsController < ApplicationController
+    before_action :find_dashboard_class
+
+    def show
+      @dashboard_instance = @dashboard_class.new(dashboard_params)
+      
+      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.json { render json: dashboard_data }
+      end
+    end
+
+    def card
+      @dashboard_instance = @dashboard_class.new(dashboard_params)
+      @card = @dashboard_class.find_card(params[:card_name])
+      
+      unless @card
+        render json: { error: "Card not found" }, status: :not_found
+        return
+      end
+
+      @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.json { render json: @card_data }
+      end
+    rescue => e
+      Rails.logger.error "Dashboard card error: #{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.json { render json: { error: e.message }, status: :server_error }
+      end
+    end
+
+    private
+
+    def find_dashboard_class
+      @dashboard_class = EasyAdmin::DashboardRegistry.find(params[:dashboard_name])
+      
+      unless @dashboard_class
+        raise "Dashboard '#{params[:dashboard_name]}' not found"
+      end
+    end
+
+    def dashboard_params
+      params.permit(:date_from, :date_to, :segment, :search, :period, :refresh)
+    end
+
+    def dashboard_data
+      {
+        title: @dashboard_class.title,
+        columns: @dashboard_class.columns,
+        cards: @dashboard_class.visible_cards.map do |card|
+          card.merge(
+            data: @dashboard_instance.card_data(card[:name]),
+            url: card_url(card[:name])
+          )
+        end
+      }
+    end
+
+    def card_partial
+      partial_name = @card[:partial] || "easy_admin/dashboards/cards/#{@card[:type]}"
+      
+      # Check if custom partial exists
+      if lookup_context.exists?(partial_name, [], true)
+        partial_name
+      else
+        "easy_admin/dashboards/cards/#{@card[:type]}"
+      end
+    end
+
+
+    def card_url(card_name)
+      easy_admin.dashboard_card_path(
+        dashboard_name: params[:dashboard_name],
+        card_name: card_name,
+        **dashboard_params.to_h.symbolize_keys
+      )
+    end
+  end
+end

data/app/controllers/easy_admin/passwords_controller.rb

@@ -0,0 +1,15 @@
+module EasyAdmin
+  class PasswordsController < Devise::PasswordsController
+    layout 'easy_admin/auth'
+    
+    protected
+
+    def after_resetting_password_path_for(resource)
+      easy_admin.root_path
+    end
+
+    def after_sending_reset_password_instructions_path_for(resource_name)
+      new_easy_admin_admin_user_session_path
+    end
+  end
+end

data/app/controllers/easy_admin/registrations_controller.rb

@@ -0,0 +1,52 @@
+module EasyAdmin
+  class RegistrationsController < Devise::RegistrationsController
+    layout 'easy_admin/auth'
+    
+    # GET /easy_admin/sign_up
+    def new
+      super
+    end
+
+    # POST /easy_admin/sign_up
+    def create
+      super
+    end
+
+    # GET /easy_admin/edit
+    def edit
+      super
+    end
+
+    # PATCH/PUT /easy_admin/
+    def update
+      super
+    end
+
+    # DELETE /easy_admin/
+    def destroy
+      super
+    end
+
+    protected
+
+    # If you have extra params to permit, append them to the sanitizer.
+    def configure_sign_up_params
+      devise_parameter_sanitizer.permit(:sign_up, keys: [:first_name, :last_name])
+    end
+
+    # If you have extra params to permit, append them to the sanitizer.
+    def configure_account_update_params
+      devise_parameter_sanitizer.permit(:account_update, keys: [:first_name, :last_name])
+    end
+
+    # The path used after signing up
+    def after_sign_up_path_for(resource)
+      easy_admin_root_path
+    end
+
+    # The path used after account update
+    def after_update_path_for(resource)
+      easy_admin_root_path
+    end
+  end
+end