rails_admin_next 1.0.0

data/lib/rails_admin_next/adapters/active_record/property.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RailsAdminNext
+  module Adapters
+    module ActiveRecord
+      class Property
+        attr_reader :property, :model
+
+        def initialize(property, model)
+          @property = property
+          @model = model
+        end
+
+        def name
+          property.name.to_sym
+        end
+
+        def pretty_name
+          property.name.to_s.tr("_", " ").capitalize
+        end
+
+        def type
+          if serialized?
+            :serialized
+          else
+            property.type
+          end
+        end
+
+        def length
+          property.limit
+        end
+
+        def nullable?
+          property.null
+        end
+
+        def serial?
+          model.primary_key == property.name
+        end
+
+        def association?
+          false
+        end
+
+        def read_only?
+          model.readonly_attributes.include? property.name.to_s
+        end
+
+        private
+
+        def serialized?
+          model.type_for_attribute(property.name).instance_of?(::ActiveRecord::Type::Serialized)
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin_next/adapters/active_record.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "rails_admin_next/adapters/active_record/association"
+require "rails_admin_next/adapters/active_record/object_extension"
+require "rails_admin_next/adapters/active_record/property"
+
+module RailsAdminNext
+  module Adapters
+    module ActiveRecord
+      DISABLED_COLUMN_TYPES = %i[tsvector blob binary spatial hstore geometry].freeze
+
+      def new(params = {})
+        model.new(params).extend(ObjectExtension)
+      end
+
+      def get(id, scope = scoped)
+        object = primary_key_scope(scope, id).first
+        return unless object
+
+        object.extend(ObjectExtension)
+      end
+
+      def scoped
+        model.all
+      end
+
+      def first(options = {}, scope = nil)
+        all(options, scope).first
+      end
+
+      def all(options = {}, scope = nil)
+        scope ||= scoped
+        scope = scope.includes(options[:include]) if options[:include]
+        scope = scope.limit(options[:limit]) if options[:limit]
+        scope = bulk_scope(scope, options) if options[:bulk_ids]
+        scope = query_scope(scope, options[:query]) if options[:query]
+        scope = filter_scope(scope, options[:filters]) if options[:filters]
+        scope = sort_scope(scope, options) if options[:sort]
+        scope = paginate_scope(scope, options[:page], options[:per]) if options[:page] && options[:per]
+        scope
+      end
+
+      def count(options = {}, scope = nil)
+        all(options.merge(limit: false, page: false), scope).count(:all)
+      end
+
+      def destroy(objects)
+        Array.wrap(objects).each(&:destroy)
+      end
+
+      def associations
+        model.reflect_on_all_associations.collect do |association|
+          Association.new(association, model)
+        end
+      end
+
+      def properties
+        columns = model.columns.reject do |c|
+          c.type.blank? ||
+            DISABLED_COLUMN_TYPES.include?(c.type.to_sym) ||
+            c.try(:array)
+        end
+        columns.collect do |property|
+          Property.new(property, model)
+        end
+      end
+
+      def base_class
+        model.base_class
+      end
+
+      delegate :primary_key, :table_name, to: :model, prefix: false
+
+      def quoted_table_name
+        model.quoted_table_name
+      end
+
+      def quote_column_name(name)
+        model.connection.quote_column_name(name)
+      end
+
+      def encoding
+        adapter = ::ActiveRecord::Base.connection_db_config.configuration_hash[:adapter]
+        case adapter
+        when "postgresql"
+          ::ActiveRecord::Base.connection.select_one("SELECT ''::text AS str;").values.first.encoding
+        when "mysql2"
+          if RUBY_ENGINE == "jruby"
+            ::ActiveRecord::Base.connection.select_one("SELECT '' AS str;").values.first.encoding
+          else
+            ::ActiveRecord::Base.connection.raw_connection.encoding
+          end
+        when "oracle_enhanced"
+          ::ActiveRecord::Base.connection.select_one("SELECT dummy FROM DUAL").values.first.encoding
+        else
+          ::ActiveRecord::Base.connection.select_one("SELECT '' AS str;").values.first.encoding
+        end
+      end
+
+      def embedded?
+        false
+      end
+
+      def cyclic?
+        false
+      end
+
+      def adapter_supports_joins?
+        true
+      end
+
+      def format_id(id)
+        if primary_key.is_a? Array
+          RailsAdminNext.config.composite_keys_serializer.serialize(id)
+        else
+          id
+        end
+      end
+
+      def parse_id(id)
+        if primary_key.is_a?(Array)
+          ids = RailsAdminNext.config.composite_keys_serializer.deserialize(id)
+          primary_key.each_with_index do |key, i|
+            ids[i] = model.type_for_attribute(key).cast(ids[i])
+          end
+          ids
+        else
+          id
+        end
+      end
+
+      private
+
+      def primary_key_scope(scope, id)
+        if primary_key.is_a? Array
+          scope.where(primary_key.zip(parse_id(id)).to_h)
+        else
+          scope.where(primary_key => id)
+        end
+      end
+
+      def bulk_scope(scope, options)
+        if primary_key.is_a? Array
+          options[:bulk_ids].map { |id| primary_key_scope(scope, id) }.reduce(&:or)
+        else
+          scope.where(primary_key => options[:bulk_ids])
+        end
+      end
+
+      def sort_scope(scope, options)
+        direction = options[:sort_reverse] ? :asc : :desc
+        case options[:sort]
+        when String, Symbol
+          scope.reorder("#{options[:sort]} #{direction}")
+        when Array
+          scope.reorder(options[:sort].zip(Array.new(options[:sort].size) { direction }).to_h)
+        when Hash
+          scope.reorder(options[:sort].map { |table_name, column| "#{table_name}.#{column}" }
+            .zip(Array.new(options[:sort].size) { direction }).to_h)
+        else
+          raise ArgumentError.new("Unsupported sort value: #{options[:sort]}")
+        end
+      end
+
+      # Offset-mode pagination over the (already ordered/filtered) relation.
+      # geared_pagination runs the real LIMIT/OFFSET/COUNT; the returned
+      # PaginatedCollection is the thin view-facing wrapper.
+      def paginate_scope(scope, page, per)
+        per = [per.to_i, 1].max
+        recordset = GearedPagination::Recordset.new(scope, per_page: per)
+        RailsAdminNext::PaginatedCollection.from_recordset(recordset, page, per)
+      end
+
+      class WhereBuilder
+        def initialize(scope)
+          @statements = []
+          @values = []
+          @tables = []
+          @scope = scope
+        end
+
+        def add(field, value, operator)
+          field.searchable_columns.flatten.each do |column_infos|
+            statement, value1, value2 = StatementBuilder.new(column_infos[:column], column_infos[:type], value, operator, @scope.connection.adapter_name).to_statement
+            @statements << statement if statement.present?
+            @values << value1 unless value1.nil?
+            @values << value2 unless value2.nil?
+            table, column = column_infos[:column].split(".")
+            @tables.push(table) if column
+          end
+        end
+
+        def build
+          scope = @scope.where(@statements.join(" OR "), *@values)
+          scope = scope.references(*@tables.uniq) if @tables.any?
+          scope
+        end
+      end
+
+      def query_scope(scope, query, fields = config.list.fields.select(&:queryable?))
+        if config.list.search_by
+          scope.send(config.list.search_by, query)
+        else
+          wb = WhereBuilder.new(scope)
+          fields.each do |field|
+            value = parse_field_value(field, query)
+            wb.add(field, value, field.search_operator)
+          end
+          # OR all query statements
+          wb.build
+        end
+      end
+
+      # filters example => {"string_field"=>{"0055"=>{"o"=>"like", "v"=>"test_value"}}, ...}
+      # "0055" is the filter index, no use here. o is the operator, v the value
+      def filter_scope(scope, filters, fields = config.list.fields.select(&:filterable?))
+        filters.each_pair do |field_name, filters_dump|
+          filters_dump.each_value do |filter_dump|
+            wb = WhereBuilder.new(scope)
+            field = fields.detect { |f| f.name.to_s == field_name }
+            value = parse_field_value(field, filter_dump[:v])
+
+            wb.add(field, value, filter_dump[:o] || RailsAdminNext::Config.default_search_operator)
+            # AND current filter statements to other filter statements
+            scope = wb.build
+          end
+        end
+        scope
+      end
+
+      def build_statement(column, type, value, operator)
+        StatementBuilder.new(column, type, value, operator, model.connection.adapter_name).to_statement
+      end
+
+      class StatementBuilder < RailsAdminNext::AbstractModel::StatementBuilder
+        def initialize(column, type, value, operator, adapter_name)
+          super(column, type, value, operator)
+          @adapter_name = adapter_name
+        end
+
+        protected
+
+        def unary_operators
+          case @type
+          when :boolean
+            boolean_unary_operators
+          when :uuid
+            uuid_unary_operators
+          when :integer, :decimal, :float
+            numeric_unary_operators
+          else
+            generic_unary_operators
+          end
+        end
+
+        private
+
+        def generic_unary_operators
+          {
+            "_blank" => ["(#{@column} IS NULL OR #{@column} = '')"],
+            "_present" => ["(#{@column} IS NOT NULL AND #{@column} != '')"],
+            "_null" => ["(#{@column} IS NULL)"],
+            "_not_null" => ["(#{@column} IS NOT NULL)"],
+            "_empty" => ["(#{@column} = '')"],
+            "_not_empty" => ["(#{@column} != '')"]
+          }
+        end
+
+        def boolean_unary_operators
+          generic_unary_operators.merge(
+            "_blank" => ["(#{@column} IS NULL)"],
+            "_empty" => ["(#{@column} IS NULL)"],
+            "_present" => ["(#{@column} IS NOT NULL)"],
+            "_not_empty" => ["(#{@column} IS NOT NULL)"]
+          )
+        end
+        alias_method :numeric_unary_operators, :boolean_unary_operators
+        alias_method :uuid_unary_operators, :boolean_unary_operators
+
+        def range_filter(min, max)
+          if min && max && min == max
+            ["(#{@column} = ?)", min]
+          elsif min && max
+            ["(#{@column} BETWEEN ? AND ?)", min, max]
+          elsif min
+            ["(#{@column} >= ?)", min]
+          elsif max
+            ["(#{@column} <= ?)", max]
+          end
+        end
+
+        def build_statement_for_type
+          case @type
+          when :boolean then build_statement_for_boolean
+          when :integer, :decimal, :float then build_statement_for_integer_decimal_or_float
+          when :string, :text, :citext then build_statement_for_string_or_text
+          when :enum then build_statement_for_enum
+          when :belongs_to_association then build_statement_for_belongs_to_association
+          when :uuid then build_statement_for_uuid
+          end
+        end
+
+        def build_statement_for_boolean
+          case @value
+          when "false", "f", "0"
+            ["(#{@column} IS NULL OR #{@column} = ?)", false]
+          when "true", "t", "1"
+            ["(#{@column} = ?)", true]
+          end
+        end
+
+        def column_for_value(value)
+          ["(#{@column} = ?)", value]
+        end
+
+        def build_statement_for_belongs_to_association
+          return if @value.blank?
+
+          ["(#{@column} = ?)", @value.to_i] if @value.to_i.to_s == @value
+        end
+
+        def build_statement_for_string_or_text
+          return if @value.blank?
+
+          return ["(#{@column} = ?)", @value] if ["is", "="].include?(@operator)
+
+          @value = @value.downcase unless %w[postgresql postgis].include? ar_adapter
+
+          @value =
+            case @operator
+            when "default", "like", "not_like"
+              "%#{@value}%"
+            when "starts_with"
+              "#{@value}%"
+            when "ends_with"
+              "%#{@value}"
+            else
+              return
+            end
+
+          if %w[postgresql postgis].include? ar_adapter
+            if @operator == "not_like"
+              ["(#{@column} NOT ILIKE ?)", @value]
+            else
+              ["(#{@column} ILIKE ?)", @value]
+            end
+          elsif @operator == "not_like"
+            ["(LOWER(#{@column}) NOT LIKE ?)", @value]
+          else
+            ["(LOWER(#{@column}) LIKE ?)", @value]
+          end
+        end
+
+        def build_statement_for_enum
+          return if @value.blank?
+
+          ["(#{@column} IN (?))", Array.wrap(@value)]
+        end
+
+        def build_statement_for_uuid
+          column_for_value(@value) if /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/.match?(@value.to_s)
+        end
+
+        def ar_adapter
+          @adapter_name.downcase
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/actions/base.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "rails_admin_next/config/proxyable"
+require "rails_admin_next/config/configurable"
+require "rails_admin_next/config/hideable"
+
+module RailsAdminNext
+  module Config
+    module Actions
+      class Base
+        include RailsAdminNext::Config::Proxyable
+        include RailsAdminNext::Config::Configurable
+        include RailsAdminNext::Config::Hideable
+
+        register_instance_option :only do
+          nil
+        end
+
+        register_instance_option :except do
+          []
+        end
+
+        register_instance_option :show_in_navigation do
+          root?
+        end
+
+        register_instance_option :show_in_sidebar do
+          !show_in_navigation
+        end
+
+        register_instance_option :show_in_menu do
+          true
+        end
+
+        register_instance_option :sidebar_label do
+          nil
+        end
+
+        # Logical icon name resolved to inline SVG by rails_admin_icon (see RailsAdminNext::Icons::GLYPHS).
+        register_instance_option :link_icon do
+          :bulk_delete
+        end
+
+        # Should the action be visible
+        register_instance_option :visible? do
+          authorized?
+        end
+
+        register_instance_option :enabled? do
+          bindings[:abstract_model].nil? || (only.nil? || [only].flatten.collect(&:to_s).include?(bindings[:abstract_model].to_s)) &&
+            ![except].flatten.collect(&:to_s).include?(bindings[:abstract_model].to_s) &&
+            !bindings[:abstract_model].config.excluded? && (!respond_to?(:writable?) || writable?)
+        end
+
+        register_instance_option :authorized? do
+          enabled? && (
+            bindings[:controller].try(:authorization_adapter).nil? || bindings[:controller].authorization_adapter.authorized?(authorization_key, bindings[:abstract_model], bindings[:object])
+          )
+        end
+
+        # Is the action acting on the root level (Example: /admin/contact)
+        register_instance_option :root? do
+          false
+        end
+
+        # Is the action on a model scope (Example: /admin/team/export)
+        register_instance_option :collection? do
+          false
+        end
+
+        # Is the action on an object scope (Example: /admin/team/1/edit)
+        register_instance_option :member? do
+          false
+        end
+
+        # Target window [_self, _blank]
+        register_instance_option :link_target do
+          nil
+        end
+
+        # Determines whether to navigate via Turbo Drive or not
+        register_instance_option :turbo? do
+          true
+        end
+
+        # This block is evaluated in the context of the controller when action is called
+        # You can access:
+        # - @objects if you're on a model scope
+        # - @abstract_model & @model_config if you're on a model or object scope
+        # - @object if you're on an object scope
+        register_instance_option :controller do
+          proc do
+            render action: @action.template_name
+          end
+        end
+
+        # Model scoped actions only. You will need to handle params[:bulk_ids] in controller
+        register_instance_option :bulkable? do
+          false
+        end
+
+        # View partial name (called in default :controller block)
+        register_instance_option :template_name do
+          key.to_sym
+        end
+
+        # For CanCanCan and the like
+        register_instance_option :authorization_key do
+          key.to_sym
+        end
+
+        # List of methods allowed. Note that you are responsible for correctly handling them in :controller block
+        register_instance_option :http_methods do
+          [:get]
+        end
+
+        # Url fragment
+        register_instance_option :route_fragment do
+          custom_key.to_s
+        end
+
+        # Controller action name
+        register_instance_option :action_name do
+          custom_key.to_sym
+        end
+
+        # I18n key
+        register_instance_option :i18n_key do
+          key
+        end
+
+        # User should override only custom_key (action name and route fragment change, allows for duplicate actions)
+        register_instance_option :custom_key do
+          key
+        end
+
+        # Breadcrumb parent
+        register_instance_option :breadcrumb_parent do
+          if root?
+            [:dashboard]
+          elsif collection?
+            [:index, bindings[:abstract_model]]
+          elsif member?
+            [:show, bindings[:abstract_model], bindings[:object]]
+          end
+        end
+
+        # Off API.
+
+        def key
+          self.class.key
+        end
+
+        def self.key
+          name.to_s.demodulize.underscore.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/actions/bulk_delete.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RailsAdminNext
+  module Config
+    module Actions
+      class BulkDelete < RailsAdminNext::Config::Actions::Base
+        RailsAdminNext::Config::Actions.register(self)
+
+        register_instance_option :collection do
+          true
+        end
+
+        register_instance_option :http_methods do
+          %i[post delete]
+        end
+
+        register_instance_option :controller do
+          proc do
+            if request.post? # BULK DELETE
+              @objects = list_entries(@model_config, :destroy)
+
+              if @objects.blank?
+                flash[:error] = t("admin.flash.error", name: pluralize(0, @model_config.label), action: t("admin.actions.delete.done"))
+                redirect_to index_path
+              else
+                render @action.template_name
+              end
+
+            elsif request.delete? # BULK DESTROY
+
+              destroyed = nil
+              not_destroyed = nil
+
+              unless params[:bulk_ids].blank?
+                @objects = list_entries(@model_config, :destroy)
+                unless @objects.blank?
+                  processed_objects = @abstract_model.destroy(@objects)
+                  destroyed = processed_objects.select(&:destroyed?)
+                  not_destroyed = processed_objects - destroyed
+                  destroyed.each do |object|
+                    @auditing_adapter&.delete_object(object, @abstract_model, _current_user)
+                  end
+                end
+              end
+
+              if destroyed.nil?
+                flash[:error] = t("admin.flash.error", name: pluralize(0, @model_config.label), action: t("admin.actions.delete.done"))
+              else
+                flash[:success] = t("admin.flash.successful", name: pluralize(destroyed.count, @model_config.label), action: t("admin.actions.delete.done")) unless destroyed.empty?
+                flash[:error] = t("admin.flash.error", name: pluralize(not_destroyed.count, @model_config.label), action: t("admin.actions.delete.done")) unless not_destroyed.empty?
+              end
+              redirect_to back_or_index
+            end
+          end
+        end
+
+        register_instance_option :authorization_key do
+          :destroy
+        end
+
+        register_instance_option :bulkable? do
+          true
+        end
+      end
+    end
+  end
+end