easy-admin-rails 0.1.14 → 0.2.0

data/lib/easy_admin/permissions/user_extensions.rb

@@ -0,0 +1,129 @@
+module EasyAdmin
+  module Permissions
+    module UserExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :user_roles, class_name: 'EasyAdmin::Permissions::UserRole', foreign_key: 'user_id', dependent: :destroy
+        has_many :roles, through: :user_roles, class_name: 'EasyAdmin::Permissions::Role'
+        has_many :permissions, through: :roles, class_name: 'EasyAdmin::Permissions::Permission'
+
+        # Cache for computed permissions (JSON columns handle serialization automatically)
+      end
+
+      # Check if user has specific permission
+      def has_permission?(permission_name, context: nil)
+        return false unless EasyAdmin::Permissions.enabled?
+        return false unless respond_to?(:permissions_cache)
+        return false unless permissions_cache.present?
+
+        # For now, ignore context and just use flat permission structure
+        permission_value = permissions_cache[permission_name.to_s]
+        
+        # Check if permission exists in cache (handle both string and boolean values)
+        return true if permission_value == "true" || permission_value == true
+        return false if permission_value == "false" || permission_value == false
+        
+        # If not explicitly set, default to false
+        false
+      end
+
+      # Check if user has specific role
+      def has_role?(role_name, context: nil)
+        user_roles.active.includes(:role).any? do |user_role|
+          next false if context && user_role.context != context
+          user_role.role.slug == role_name.to_s || user_role.role.name == role_name.to_s
+        end
+      end
+
+      # Get all user permissions for a context
+      def calculate_permissions(context: nil)
+        return [] unless EasyAdmin::Permissions.enabled?
+        return [] unless respond_to?(:permissions_cache)
+        return [] unless permissions_cache.present?
+
+        # Return only permissions that are explicitly set to true
+        permissions_cache.select { |k, v| v == "true" || v == true }.keys
+      end
+
+      # Set user permissions directly in cache
+      def set_permission(permission_name, value = true, context: nil)
+        return false unless EasyAdmin::Permissions.enabled?
+        return false unless respond_to?(:permissions_cache=)
+
+        context_key = context&.cache_key || 'global'
+        current_cache = permissions_cache || {}
+        
+        if context
+          current_cache[context_key] ||= {}
+          current_cache[context_key][permission_name.to_s] = value.to_s
+        else
+          current_cache[permission_name.to_s] = value.to_s
+        end
+        
+        if persisted?
+          update_column(:permissions_cache, current_cache)
+        else
+          self.permissions_cache = current_cache
+        end
+        
+        true
+      end
+
+      # Remove permission from cache  
+      def remove_permission(permission_name, context: nil)
+        return false unless EasyAdmin::Permissions.enabled?
+        return false unless respond_to?(:permissions_cache=)
+
+        context_key = context&.cache_key || 'global'
+        current_cache = permissions_cache || {}
+        
+        if context && current_cache[context_key]
+          current_cache[context_key].delete(permission_name.to_s)
+        else
+          current_cache.delete(permission_name.to_s)
+        end
+        
+        if persisted?
+          update_column(:permissions_cache, current_cache)
+        else
+          self.permissions_cache = current_cache
+        end
+        
+        true
+      end
+
+      # Get all roles for user in specific context
+      def roles_for_context(context = nil)
+        if context
+          user_roles.active.for_context(context).includes(:role).map(&:role)
+        else
+          user_roles.active.global.includes(:role).map(&:role)
+        end
+      end
+
+      # Clear permission cache
+      def clear_permissions_cache!
+        if respond_to?(:permissions_cache=)
+          if persisted?
+            update_column(:permissions_cache, {})
+          else
+            self.permissions_cache = {}
+          end
+        end
+      end
+
+      private
+
+      def find_role(role_identifier)
+        if role_identifier.is_a?(String) || role_identifier.is_a?(Symbol)
+          EasyAdmin::Permissions::Role.find_by(slug: role_identifier.to_s) ||
+          EasyAdmin::Permissions::Role.find_by(name: role_identifier.to_s)
+        else
+          role_identifier
+        end
+      end
+
+    end
+  end
+end

data/lib/easy_admin/permissions.rb

@@ -0,0 +1,113 @@
+# EasyAdmin Permission Engine
+# A lightweight permission management system that works with Action Policy
+
+module EasyAdmin
+  module Permissions
+    extend ActiveSupport::Autoload
+
+    autoload :Engine
+    autoload :Models
+    autoload :DSL
+    autoload :Controller
+    autoload :Component
+    autoload :Cache
+    autoload :Configuration
+    autoload :UserExtensions
+    autoload :ResourcePermissions
+    autoload :RoleDefinition
+    autoload :RoleDSL
+
+    class << self
+      attr_writer :configuration, :role_definitions
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+      end
+
+      # Check if permissions are enabled
+      def enabled?
+        configuration.enabled
+      end
+
+      # Restore the original define method for the DSL
+      def define(&block)
+        DSL.evaluate(&block).tap do |data|
+          DSL.seed_database(data)
+        end
+      end
+
+      # DSL for defining roles
+      def define_roles(&block)
+        @role_definitions = RoleDSL.new
+        @role_definitions.instance_eval(&block)
+        @role_definitions
+      end
+
+      # Get defined roles
+      def role_definitions
+        @role_definitions ||= RoleDSL.new
+      end
+
+      # Get all available roles
+      def available_roles
+        role_definitions.all_roles
+      end
+
+      # Get role by slug
+      def get_role(slug)
+        role_definitions.get_role(slug)
+      end
+
+      # Core permission check - used by Action Policy policies
+      def authorized?(user, permission_name, context: nil)
+        return true unless enabled?
+        return true if user.id == 1
+        
+        user&.has_permission?(permission_name, context: context) || false
+      end
+
+      # Check if user has role
+      def has_role?(user, role_name, context: nil)
+        return false unless user
+        user.has_role?(role_name, context: context)
+      end
+
+      # Get user permissions based on role
+      def user_permissions_for_role(role_slug)
+        role = get_role(role_slug)
+        return {} unless role
+        role.permissions
+      end
+
+      # Get available EasyAdmin resources
+      def available_resources
+        ResourcePermissions.available_resources
+      end
+
+      # Get actions for a specific resource
+      def actions_for_resource(resource_name)
+        ResourcePermissions.actions_for_resource(resource_name)
+      end
+
+      # Generate all possible permissions for available resources
+      def generate_all_permissions
+        permissions = {}
+        available_resources.each do |resource|
+          actions_for_resource(resource).each do |action|
+            permission_key = "#{resource}:#{action}"
+            permissions[permission_key] = {
+              resource: resource,
+              action: action,
+              name: permission_key
+            }
+          end
+        end
+        permissions
+      end
+    end
+  end
+end

data/lib/easy_admin/resource/base.rb

@@ -0,0 +1,119 @@
+module EasyAdmin
+  module ResourceModules
+    # Base module that provides the core resource functionality
+    # This module serves as the orchestrator for all resource modules
+    module Base
+      extend ActiveSupport::Concern
+
+      included do
+        include EasyAdmin::Versioning
+        include EasyAdmin::ResourceModules::Configuration
+        include EasyAdmin::ResourceModules::DSL
+        include EasyAdmin::ResourceModules::FieldRegistry
+        include EasyAdmin::ResourceModules::LayoutBuilder
+        include EasyAdmin::ResourceModules::ScopeManager
+        
+        # Class attributes for core functionality
+        class_attribute :resource_name, :custom_title
+        
+        # Initialize configurations when resource is inherited
+        def self.inherited(subclass)
+          super
+          subclass.setup_resource_defaults
+          EasyAdmin::ResourceRegistry.register(subclass)
+        end
+
+        # Set up default configurations for new resource classes
+        def self.setup_resource_defaults
+          self.resource_name = name.demodulize.gsub(/Resource$/, '')
+          initialize_configurations
+          initialize_field_registry
+          initialize_layout_builder
+          initialize_scope_manager
+        end
+      end
+
+      class_methods do
+        # Get the associated model class
+        def model_class
+          model_class_name.constantize
+        rescue NameError
+          raise "Model class #{model_class_name} not found. Make sure the model exists."
+        end
+
+        # Get resource title/name
+        def title
+          return custom_title.pluralize if custom_title.present?
+          resource_name.underscore.humanize.pluralize
+        end
+
+        def singular_title
+          return custom_title.singularize if custom_title.present?
+          resource_name.underscore.humanize
+        end
+
+        # Route helpers
+        def route_key
+          resource_name.underscore.pluralize
+        end
+
+        def param_key
+          resource_name.underscore
+        end
+
+        # DSL for setting custom title
+        def resource_title(title_name)
+          self.custom_title = title_name.to_s
+        end
+
+        # Query methods - delegated to field registry
+        def all_records(sort_field: nil, sort_direction: 'asc')
+          records = model_class.all
+          
+          if sort_field.present? && sortable_fields.any? { |f| f[:name].to_s == sort_field.to_s }
+            records = records.order("#{sort_field} #{sort_direction}")
+          end
+          
+          records
+        end
+
+        def find_record(id)
+          model_class.find(id)
+        end
+
+        def search_records(query, sort_field: nil, sort_direction: 'asc', records: nil)
+          records ||= model_class.all
+          searchable_fields = fields_config.select { |field| field[:searchable] }
+          
+          if searchable_fields.any? && query.present?
+            conditions = searchable_fields.map do |field|
+              "#{field[:name]} ILIKE ?"
+            end.join(' OR ')
+
+            values = Array.new(searchable_fields.length, "%#{query}%")
+            records = records.where(conditions, *values)
+          end
+          
+          if sort_field.present? && sortable_fields.any? { |f| f[:name].to_s == sort_field.to_s }
+            records = records.order("#{sort_field} #{sort_direction}")
+          end
+          
+          records
+        end
+
+        # Versioning DSL - Simple API for enabling version viewing
+        def versioning(enabled = true, **options)
+          if enabled
+            enable_versioning(options)
+          else
+            self.versioning_enabled = false
+          end
+        end
+        
+        def has_versioning?
+          model_has_versions?
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/resource/configuration.rb

@@ -0,0 +1,148 @@
+module EasyAdmin
+  module ResourceModules
+    # Configuration module for handling resource settings
+    # Manages pagination, includes, batch actions, and row actions
+    module Configuration
+      extend ActiveSupport::Concern
+
+      included do
+        # Core configuration class attributes
+        class_attribute :model_class_name, :pagination_config, :includes_config, 
+                        :batch_actions_config, :batch_actions_enabled, :row_actions_config
+
+        # Initialize default configurations
+        def self.initialize_configurations
+          self.model_class_name = resource_name
+          self.pagination_config = {
+            type: :standard,
+            per_page: 20,
+            max_per_page: 100
+          }
+          self.includes_config = {
+            index: [],
+            show: [],
+            form: []
+          }
+          self.batch_actions_config = []
+          self.batch_actions_enabled = false
+          self.row_actions_config = []
+        end
+      end
+
+      class_methods do
+        # Pagination configuration
+        def pagination(type: :standard, per_page: 20, **options)
+          self.pagination_config = {
+            type: type,
+            per_page: per_page,
+            max_per_page: options[:max_per_page] || 100,
+            infinite_scroll: options[:infinite_scroll] || false,
+            countless: options[:countless] || false
+          }
+        end
+
+        # Configure eager loading for associations
+        def includes(associations, actions: [:index, :show, :form])
+          actions = Array(actions)
+          
+          actions.each do |action|
+            if self.includes_config.key?(action)
+              self.includes_config = self.includes_config.merge(
+                action => Array(associations)
+              )
+            end
+          end
+        end
+
+        # Convenience methods for pagination configuration
+        def per_page(count)
+          pagination(per_page: count)
+        end
+
+        def infinite_scroll(**options)
+          pagination(type: :infinite_scroll, infinite_scroll: true, **options)
+        end
+
+        def countless_pagination(**options)
+          pagination(countless: true, **options)
+        end
+
+        # Pagination helper methods
+        def items_per_page
+          pagination_config[:per_page]
+        end
+
+        def max_items_per_page
+          pagination_config[:max_per_page]
+        end
+
+        def pagination_type
+          pagination_config[:type]
+        end
+
+        def infinite_scroll_enabled?
+          pagination_config[:infinite_scroll]
+        end
+
+        def countless_enabled?
+          pagination_config[:countless]
+        end
+
+        # Includes configuration helpers
+        def index_includes
+          includes_config[:index] || []
+        end
+
+        def show_includes
+          includes_config[:show] || []
+        end
+
+        def form_includes
+          includes_config[:form] || []
+        end
+
+        # Batch Actions configuration
+        def add_batch_action(action_class, options = {})
+          self.batch_actions_config = (self.batch_actions_config || []) + [{
+            class: action_class,
+            condition: options[:if]
+          }]
+        end
+
+        def batch_actions
+          batch_actions_config || []
+        end
+
+        def has_batch_actions?
+          batch_actions_enabled && batch_actions_config.any?
+        end
+
+        # Row Actions configuration
+        def add_row_action(action_class, options = {})
+          self.row_actions_config = (self.row_actions_config || []) + [{
+            class: action_class,
+            condition: options[:if]
+          }]
+        end
+        
+        def row_actions
+          row_actions_config || []
+        end
+        
+        def has_row_actions?
+          row_actions_config.present?
+        end
+
+        # Available actions based on context conditions
+        def available_row_actions(context = {})
+          return [] unless has_row_actions?
+          
+          row_actions_config.select do |config|
+            condition = config[:condition]
+            condition.nil? || (condition.respond_to?(:call) ? context.instance_eval(&condition) : condition)
+          end.map { |config| config[:class] }
+        end
+      end
+    end
+  end
+end

data/lib/easy_admin/resource/dsl.rb

@@ -0,0 +1,117 @@
+module EasyAdmin
+  module ResourceModules
+    # DSL module for defining fields and convenience methods
+    # Handles all field definition methods and form building
+    module DSL
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # DSL for setting custom model name
+        def model(model_name)
+          self.model_class_name = model_name.to_s
+        end
+
+        # Core field definition method
+        def field(name, type = :string, **options)
+          register_field(name, type, **options)
+        end
+
+        # Convenience methods for common field types
+        def id_field(**options)
+          field(:id, :number, readonly: true, **options)
+        end
+
+        def text_field(name, **options)
+          field(name, :string, **options)
+        end
+
+        def textarea_field(name, **options)
+          field(name, :text, **options)
+        end
+
+        def number_field(name, **options)
+          field(name, :number, **options)
+        end
+
+        def email_field(name, **options)
+          field(name, :email, **options)
+        end
+
+        def date_field(name, **options)
+          field(name, :date, **options)
+        end
+
+        def datetime_field(name, **options)
+          field(name, :datetime, **options)
+        end
+
+        def boolean_field(name, **options)
+          field(name, :boolean, **options)
+        end
+
+        def select_field(name, options:, **other_options)
+          field(name, :select, options: options, **other_options)
+        end
+
+        def belongs_to_field(name, **options)
+          field(name, :belongs_to, **options)
+        end
+
+        def has_many_field(name, **options)
+          field(name, :has_many, **options)
+        end
+
+        def file_field(name, **options)
+          field(name, :file, **options)
+        end
+
+        def json_field(name, **options)
+          field(name, :json, **options)
+        end
+
+        # Password field with confirmation - new convenience method
+        def password_field(name = :password, **options)
+          field(name, :password, **options)
+          field("#{name}_confirmation".to_sym, :password, 
+                label: options[:confirmation_label] || "Confirm #{name.to_s.humanize}",
+                **options.except(:confirmation_label))
+        end
+
+        # Form building DSL
+        def form(&block)
+          form_builder = EasyAdmin::ResourceModules::FormBuilder.new(self)
+          form_builder.instance_eval(&block)
+        end
+
+        # Show layout building DSL  
+        def show(&block)
+          show_builder = EasyAdmin::ResourceModules::ShowBuilder.new(self)
+          show_builder.instance_eval(&block)
+        end
+
+        # Batch Actions DSL
+        def enable_batch_actions
+          self.batch_actions_enabled = true
+        end
+        
+        def batch_action(action_class, options = {})
+          add_batch_action(action_class, options)
+        end
+        
+        def available_batch_actions(context = {})
+          return [] unless batch_actions_enabled
+          
+          batch_actions_config.select do |config|
+            condition = config[:condition]
+            condition.nil? || (condition.respond_to?(:call) ? context.instance_eval(&condition) : condition)
+          end.map { |config| config[:class] }
+        end
+
+        # Row Actions DSL (single record actions)
+        def row_action(action_class, options = {})
+          add_row_action(action_class, options)
+        end
+      end
+    end
+  end
+end