Solution for filtering models having polymorphic belongs_to associations

[vjt]

Hi,

in order to have select-based index filters on models having a polymorphic belongs_to, I've hacked away the following new PolymorphicSelect input, leveraging MetaSearch multi-level associations syntax.

Given the model:

class Foo
  belongs_to :entity, :polymorphic => true
end

This input in app/admin/active_admin/inputs/filter_polymorphic_select_input.rb:

module ActiveAdmin::Inputs
  class FilterPolymorphicSelectInput < FilterSelectInput
    def initialize(*args)
      name, options = args.slice(4, 2)

      @_poly_type  = name
      @_poly_assoc = options[:on] or raise(":polymorphic_select needs the polymorphic association name in the :on option")

      super
    end

    # MetaSearch syntax for polymorphic associations
    def input_name
      "#{@_poly_assoc}_#{@_poly_type}_type_id_eq"
    end

  end
end

Referenced in a register block:

ActiveAdmin.register Foo do
  filter :bar, :as => :polymorphic_select, :on => :entity, :collection => proc { Bar.all }
  filter :baz, :as => :polymorphic_select, :on => :entity, :collection => proc { Baz.all }
end

Will yield two selects in the filters sidebar, behaving as you would expect, making MetaSearch generate where entity_type = "bar" and entity_id = 42.

There's still room for improvement, e.g. by automagically loading the :collection or automagically invoking the :polymorphic_select (with a better name) if the :on option is present and the reflection says it is a polymorphic association.

What do you think?

[vjt]

And here is another one that allows you to filter on deeply nested associations:

module ActiveAdmin::Inputs
  class FilterCustomStringInput < FilterStringInput
    def initialize(*args)
      name, options = args.slice(4, 2)

      @_cust_type  = name
      @_cust_value = options[:on]
      @_cust_match = options[:match] || 'contains'

      super
    end

    def input_name
      [@_cust_type, @_cust_value, @_cust_match].join('_')
    end

  end
end

Given:

class Foo < ActiveRecord::Base
  has_many :bars
end

class Bar < ActiveRecord::Base
  has_many :bazs
  # has a "value" attribute
end

class Baz < ActiveRecord::Base
  # has a "foobar" attribute
end

Usage:

ActiveAdmin.register Foo do
  filter :bars, :on => :value,  :as => :custom_string, :label => 'Bar Values'
  filter :bars_bazs, :on => :foobar, :as => :custom_string, :label => 'Baz Foobars!'
end

Thoughts:question: :-) @gregbell chime in! ;-)

[ivar]

Looks good, and this is exactly what I need..

[vjt]

@ivar hi, I improved on it, and built a more reusable module that can be included in your custom inputs, and that leaves all the construction of the meta_search filter expression to the first argument of the filter call, ensuring maximum versatility:

app/admin/active_admin/patches/meta_search.rb

# Leverage MetaSearch syntax for filters
# TODO - make it less hacky.
#
module ActiveAdmin
  module Patches
    module MetaSearch
      def initialize(*)
        super

        @_cust_field = method
        @_cust_match = if options[:match] != :none
          options[:match] || default_match
        end
      end

      def input_name
        [@_cust_field, @_cust_match].compact.join('_')
      end

      def method
        @method
      end

      private
        def default_match
          :eq
        end
    end
  end
end

app/admin/active_admin/inputs/filter_custom_select_input.rb

require 'active_admin/patches/meta_search'

module ActiveAdmin::Inputs
  class FilterCustomSelectInput < FilterSelectInput
    include ActiveAdmin::Patches::MetaSearch
  end
end

app/admin/whatever.rb

filter :entity_country_type_id, :as => :custom_select,
  :collection => proc { Country.order_by_name },
  :label => 'Search Country'

# by_status is a search_method defined in the model
filter :by_status, :as => :custom_select, :match => :none,
  :collection => [['Yes', :active], ['No', :inactive]], :label => 'Active?'

The cool thing is that this works great with the check boxes input as well:

app/admin/active_admin/inputs/filter_custom_check_boxes.rb

require 'active_admin/patches/meta_search'

module ActiveAdmin::Inputs
  class FilterCustomCheckBoxesInput < FilterCheckBoxesInput
    include ActiveAdmin::Patches::MetaSearch

    def input_name
      "#{object_name}[#{super}][]"
    end

    def choices_group_wrapping(&block)
      template.content_tag(:div, :class => 'choices_group', &block)
    end

    private
      def default_match
        :in
      end
  end
end

app/admin/foobar.rb

filter :entity_country_type_list_id, :as => :custom_check_boxes,
  :collection => proc { List.order_by_name },
  :label => 'List'

Eventually, I also have a custom_string filter:

app/admin/active_admin/inputs/filter_custom_string_input.rb

require 'active_admin/patches/meta_search'

module ActiveAdmin::Inputs
  class FilterCustomStringInput < FilterStringInput
    include ActiveAdmin::Patches::MetaSearch

    private
      def default_match
        :contains
      end
  end
end

app/admin/barbaz.rb

filter :contact_first_name_or_contact_last_name, :as => :custom_string,
  :label => 'Contact'

[shekibobo]

👍

[seanlinsley]

Hey @vjt, how come you never created a PR for this? I'd love to see that powerful polymorphic filter syntax.

For now all you can really do is filter by the DB attributes:

ActiveAdmin.register ActiveAdmin::Comment do
  filter :author_type, as: :select,
                       collection: proc{ ActiveAdmin::Comment.uniq.pluck :author_type }
end

I opened #2123 as a sounding board for these types of ideas, and also got HABTM filters working in #1928.

[vjt]

I didn't because I was a beginner and I didn't know whether it was a good idea or not. Now I know a bit more, and if you also say this is a good thing to have, I can work on a pull request - after I finish #1994 😊

[JangoSteve]

@vjt This worked well for us, thank you.

[ktowle]

@vjt Nice solution - just solved a problem for me.

[wkoffel]

Is it safe to assume this solution is dead since Rails 4 and the Ransack cutover? Very curious if anyone has done something similar there. I'm trying to avoid refactoring all my admin models. But the inability to search through nested polymorphic associations in any reasonable way has me stumped.

[seanlinsley]

@wkoffel as you noted on activerecord-hackery/ransack#152, https://github.com/activerecord-hackery/ransack/wiki/Polymorphic-searches seems to work.

[varyonic]

Can be closed?

[vjt]

I haven't followed closely AA development lately, but yes as far as I understood this is now supported through Ransack so yes it can be closed from my point of view.

Cheers and thanks!

[holyketzer]

Also you can use this:

filter :entity_of_Bar_type_id, as: :select, collection: -> { Bar.all }
filter :entity_of_Baz_type_id, as: :select, collection: -> { Baz.all }

# more general
filter :<relation_name>_of_<ModelName>_type_id, as: :select, collection: -> { 
  <ModelName>.all 
}