eluvia-base 3.37.1

data/lib/eluvia/active_record/filtering.rb

@@ -0,0 +1,680 @@
+module Eluvia
+  module ActiveRecord
+    module Filtering
+      extend ::ActiveSupport::Concern
+
+      UUID_FORMAT = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+
+      class_methods do
+
+        def filter_2(params = {}, current_user: nil)
+          p = params.to_h.symbolize_keys
+          p = parse_filter_term(p[:filter].to_s, raise_on_invalid: false) if p.key?(:filter)
+          apply_filters(self.all, p, current_user: current_user)
+        end
+
+        def filter_2!(params = {}, current_user: nil)
+          p = params.to_h.symbolize_keys
+          if p.key?(:filter)
+            p = parse_filter_term(p[:filter].to_s, raise_on_invalid: true) # raises error on invalid filter param
+            apply_filters(self.all, p, current_user: current_user, prefix: 'filter__')
+          else
+            p.each_key do |k|
+              unless permitted_filter_params.include?(k)
+                raise Eluvia::Errors::UnprocessableEntity.new({
+                  k => I18n.t('eluvia.errors.filter.unknown_param', default: 'Unknown filter param.')
+                })
+              end
+            end
+            apply_filters(self.all, p, current_user: current_user)
+          end
+        end
+
+        def search(search_term)
+          apply_search(self.all, search_term)
+        end
+
+        def apply_filters(scope, params, parent: nil, current_user: nil, prefix: '')
+          return scope if filters_model_class.nil?
+
+          # Apply filters by attribute type
+          p = params.to_h.symbolize_keys
+          scope = apply_search(scope, p[:search]) if p.key?(:search)
+          scope = apply_filters_for_filter_attrs(scope, p, parent: parent, current_user: current_user)
+          scope = apply_filters_for_has_one_attrs(scope, p, current_user: current_user)
+          scope = apply_filters_for_range_attrs(scope, p, prefix: prefix)
+          scope = apply_filters_for_uuid_attrs(scope, p, prefix: prefix)
+          scope = apply_filters_for_string_attrs(scope, p)
+          scope = apply_filters_for_integer_attrs(scope, p, prefix: prefix)
+          scope = apply_filters_for_date_attrs(scope, p, prefix: prefix)
+          apply_filters_for_boolean_attrs(scope, p)
+
+          # Return final scope
+
+        end
+
+        # Returns hash of defined filter params together with typing information and human labels
+        def filter_params
+          @filter_params ||= _filter_params
+        end
+
+        def _filter_params
+          result = {}
+          return result unless is_filters_model?(filters_model_class)
+          used_attr_names = {}
+
+          # Custom filter attr are handled with the highest priority
+          filters_model_class.filter_attrs.each do |attr_spec|
+            attr_name = attr_spec[:attr_name]
+            base = {
+              attr_name: attr_name,
+              model: filters_model_class,
+              type: attr_spec[:type],
+              label: filters_model_class.human_attribute_name(attr_name)
+            }
+            result[attr_name] = base.merge({ operator: :eq })
+            used_attr_names[attr_name] = true
+          end
+
+          # Handle has_one nested filters
+          filters_model_class.attrs(type: :has_one).each do |attr_spec|
+            next if used_attr_names.key?(attr_spec[:attr_name]) # skip if already used
+            begin
+              attr_name = attr_spec[:attr_name]
+
+              # Add base filter param expecting referenced object ID
+              base = {
+                attr_name: attr_name,
+                model: filters_model_class,
+                type: :uuid,
+                label: filters_model_class.human_attribute_name(attr_name)
+              }
+              result[attr_name] = base.merge({ operator: :eq })
+
+              # Add all nested filter params
+              filters_class_name = attr_spec[:class_name]
+              model_class_name = filters_class_name.delete_suffix("::Filters")
+              model_class = model_class_name.constantize
+              nested_filter_params = model_class.filter_params
+              nested_filter_params.each do |k, v|
+                result[:"#{attr_name}__#{k}"] = v
+              end
+
+              used_attr_names[attr_name] = true
+            rescue NameError
+              # Ignore if class not found
+            end
+          end
+
+          # Handle range attribute type
+          filters_model_class.range_attr_names.each do |attr_name|
+            next if used_attr_names.key?(attr_name) # skip if already used
+            base = {
+              attr_name: attr_name,
+              model: filters_model_class,
+              type: :range,
+              label: filters_model_class.human_attribute_name(attr_name)
+            }
+            result[attr_name] = base.merge({ operator: :eq })
+            result[:"#{attr_name}__overlap"] = base.merge({ operator: :overlap })
+            used_attr_names[attr_name] = true
+          end
+
+          # Handle simple attribute types - uuid
+          filters_model_class.attr_names(type: :uuid).each do |attr_name|
+            next if used_attr_names.key?(attr_name) # skip if already used
+            base = {
+              attr_name: attr_name,
+              model: filters_model_class,
+              type: :uuid,
+              label: filters_model_class.human_attribute_name(attr_name)
+            }
+            result[attr_name] = base.merge({ operator: :eq })
+            result[:"#{attr_name}__in"] = base.merge({ operator: :in })
+            used_attr_names[attr_name] = true
+          end
+
+          # Handle simple attribute types - string
+          filters_model_class.attr_names(type: :string).each do |attr_name|
+            next if used_attr_names.key?(attr_name) # skip if already used
+            base = {
+              attr_name: attr_name,
+              model: filters_model_class,
+              type: :string,
+              label: filters_model_class.human_attribute_name(attr_name)
+            }
+            result[attr_name] = base.merge({ operator: :eq })
+            result[:"#{attr_name}__gte"] = base.merge({ operator: :gte })
+            result[:"#{attr_name}__gt"] = base.merge({ operator: :gt })
+            result[:"#{attr_name}__lte"] = base.merge({ operator: :lte })
+            result[:"#{attr_name}__lt"] = base.merge({ operator: :lt })
+            result[:"#{attr_name}__icontains"] = base.merge({ operator: :icontains })
+            result[:"#{attr_name}__in"] = base.merge({ operator: :in })
+            used_attr_names[attr_name] = true
+          end
+
+          # Handle simple attribute types - integer
+          filters_model_class.attr_names(type: :integer).each do |attr_name|
+            next if used_attr_names.key?(attr_name) # skip if already used
+            base = {
+              attr_name: attr_name,
+              model: filters_model_class,
+              type: :integer,
+              label: filters_model_class.human_attribute_name(attr_name)
+            }
+            result[attr_name] = base.merge({ operator: :eq })
+            result[:"#{attr_name}__gte"] = base.merge({ operator: :gte })
+            result[:"#{attr_name}__gt"] = base.merge({ operator: :gt })
+            result[:"#{attr_name}__lte"] = base.merge({ operator: :lte })
+            result[:"#{attr_name}__lt"] = base.merge({ operator: :lt })
+            used_attr_names[attr_name] = true
+          end
+
+          # Handle simple attribute types - date
+          filters_model_class.attr_names(type: :date).each do |attr_name|
+            next if used_attr_names.key?(attr_name) # skip if already used
+            base = {
+              attr_name: attr_name,
+              model: filters_model_class,
+              type: :date,
+              label: filters_model_class.human_attribute_name(attr_name)
+            }
+            result[attr_name] = base.merge({ operator: :eq })
+            result[:"#{attr_name}__from"] = base.merge({ operator: :from })
+            result[:"#{attr_name}__to"] = base.merge({ operator: :to })
+            used_attr_names[attr_name] = true
+          end
+
+          # Handle simple attribute types - boolean
+          filters_model_class.attr_names(type: :boolean).each do |attr_name|
+            next if used_attr_names.key?(attr_name) # skip if already used
+            base = {
+              attr_name: attr_name,
+              model: filters_model_class,
+              type: :boolean,
+              label: filters_model_class.human_attribute_name(attr_name)
+            }
+            result[attr_name] = base.merge({ operator: :eq })
+            used_attr_names[attr_name] = true
+          end
+
+          result
+        end
+
+        # Returns array of permitted filter params usable for "strong parameters" mechanism
+        def permitted_filter_params
+          if @permitted_filter_params.nil?
+            @permitted_filter_params = _permitted_filter_params
+            @permitted_filter_params += %i[filter search] # support for a generic "filter" and "search" params
+          end
+          @permitted_filter_params
+        end
+
+        # Returns array of permitted filter params usable for "strong parameters" mechanism
+        def _permitted_filter_params
+          result = []
+          return result unless is_filters_model?(filters_model_class)
+          used_attr_names = {}
+
+          # Custom filter attr are handled with the highest priority
+          filters_model_class.filter_attrs.each do |attr_spec|
+            result << attr_spec[:attr_name]
+            used_attr_names[attr_spec[:attr_name]] = true
+          end
+
+          # Handle has_one nested filters
+          filters_model_class.attrs(type: :has_one).each do |attr_spec|
+            next if used_attr_names.key?(attr_spec[:attr_name]) # skip if already used
+            begin
+              attr_name = attr_spec[:attr_name]
+
+              # Add base filter param expecting referenced object ID
+              result << attr_name
+
+              # Add all nested filter params
+              filters_class_name = attr_spec[:class_name]
+              model_class_name = filters_class_name.delete_suffix("::Filters")
+              model_class = model_class_name.constantize
+              nested_permitted_filter_params = model_class.permitted_filter_params
+              nested_permitted_filter_params.each do |nested_attr_name|
+                if nested_attr_name.is_a?(Hash)
+                  result << { "#{attr_name}__#{nested_attr_name.keys.first}": nested_attr_name.values.first }
+                else
+                  result << :"#{attr_name}__#{nested_attr_name}"
+                end
+              end
+              used_attr_names[attr_name] = true
+            rescue NameError
+              # Ignore if class not found
+            end
+          end
+
+          # Handle range attribute type
+          filters_model_class.range_attr_names.each do |attr_name|
+            next if used_attr_names.key?(attr_name) # skip if already used
+            result << { attr_name => %i[lower upper] }
+            result << { "#{attr_name}__overlap": %i[lower upper] }
+            used_attr_names[attr_name] = true
+          end
+
+          # Handle simple attribute types - uuid
+          filters_model_class.attr_names(type: :uuid).each do |attr_name|
+            next if used_attr_names.key?(attr_name) # skip if already used
+            result << attr_name
+            result << :"#{attr_name}__in"
+            result << { "#{attr_name}__in": [] }
+            used_attr_names[attr_name] = true
+          end
+
+          # Handle simple attribute types - string
+          filters_model_class.attr_names(type: :string).each do |attr_name|
+            next if used_attr_names.key?(attr_name) # skip if already used
+            result << attr_name
+            result << :"#{attr_name}__gte"
+            result << :"#{attr_name}__gt"
+            result << :"#{attr_name}__lte"
+            result << :"#{attr_name}__lt"
+            result << :"#{attr_name}__icontains"
+            result << :"#{attr_name}__in"
+            result << { "#{attr_name}__in": [] }
+            used_attr_names[attr_name] = true
+          end
+
+          # Handle simple attribute types - integer
+          filters_model_class.attr_names(type: :integer).each do |attr_name|
+            next if used_attr_names.key?(attr_name) # skip if already used
+            result << attr_name
+            result << :"#{attr_name}__gte"
+            result << :"#{attr_name}__gt"
+            result << :"#{attr_name}__lte"
+            result << :"#{attr_name}__lt"
+            used_attr_names[attr_name] = true
+          end
+
+          # Handle simple attribute types - date
+          filters_model_class.attr_names(type: :date).each do |attr_name|
+            next if used_attr_names.key?(attr_name) # skip if already used
+            result << attr_name
+            result << :"#{attr_name}__from"
+            result << :"#{attr_name}__to"
+            used_attr_names[attr_name] = true
+          end
+
+          # Handle simple attribute types - boolean
+          filters_model_class.attr_names(type: :boolean).each do |attr_name|
+            next if used_attr_names.key?(attr_name) # skip if already used
+            result << attr_name
+            used_attr_names[attr_name] = true
+          end
+
+          result
+        end
+
+        def parse_filter_term(filter_term, raise_on_invalid: true)
+          result = {}
+          return result if filter_term.blank?
+
+          filter_term.split('&').map do |term|
+            term = term.trim
+            if term.blank?
+              if raise_on_invalid
+                raise Eluvia::Errors::UnprocessableEntity.new({
+                  "filter" => I18n.t('eluvia.errors.filter.invalid_term', default: 'Invalid filter term.')
+                })
+              else
+                next
+              end
+            end
+
+            # Parse individual term
+            begin
+              field_name, value = term.split('=', 2) # split values by '='
+              value = JSON.parse(value) # load values from the JSON format (only list, int, strings should be allowed)
+            rescue JSON::ParserError, TypeError
+              if raise_on_invalid
+                raise Eluvia::Errors::UnprocessableEntity.new({
+                  "filter__#{field_name}" => I18n.t('eluvia.errors.filter.invalid_term',
+                    default: 'Invalid filter term.')
+                })
+              else
+                next
+              end
+            end
+
+            # Check if field can be filtered
+            permitted_filter_keys = permitted_filter_params.map { |fp| fp.is_a?(Hash) ? fp.keys.first : fp }
+            unless permitted_filter_keys.include?(field_name.to_sym)
+              if raise_on_invalid
+                raise Eluvia::Errors::UnprocessableEntity.new({
+                  "filter__#{field_name}" => I18n.t('eluvia.errors.filter.unknown_param',
+                    default: 'Unknown filter param.')
+                })
+              else
+                next
+              end
+            end
+
+            result[field_name] = value
+          end
+          result
+        end
+
+        protected
+
+        def apply_search(scope, search_term)
+          return scope if search_term.blank?
+          return scope if filters_model_class.nil?
+
+          fields = filters_model_class.search_fields
+          return scope if fields.empty?
+
+          search_term.split.each do |word|
+            sql_parts = fields.map do |field|
+              col = field.is_a?(Symbol) ? "#{self.table_name}.#{field}" : field.to_s
+              "lower(unaccent(trim(#{col}))) LIKE ('%' || lower(unaccent(trim(?))) || '%')"
+            end
+            scope = scope.where(sql_parts.join(' OR '), *([word] * fields.size))
+          end
+          scope
+        end
+
+        def apply_filters_for_filter_attrs(scope, params, parent: nil, current_user: nil)
+          return scope unless is_filters_model?(filters_model_class)
+          filters_model_class.filter_attrs.each do |attr_spec|
+            attr_name = attr_spec[:attr_name]
+            value = params[attr_name]
+            next if value.blank?
+            proc = attr_spec[:proc]
+            next unless proc.respond_to?(:call)
+            scope = proc.call(
+              filters_model_class.clean_value(value, attr_name), # clean value passed to the filtering procedure
+              scope,
+              parent: parent,
+              current_user: current_user
+            )
+          end
+          scope
+        end
+
+        def apply_filters_for_has_one_attrs(scope, params, current_user: nil)
+          return scope unless is_filters_model?(filters_model_class)
+          filters_model_class.attrs(type: :has_one).each do |attr_spec|
+            next if filters_model_class.has_filter_attr?(attr_spec[:attr_name])
+            attr_name = attr_spec[:attr_name]
+            class_name = attr_spec[:class_name]
+            scope = apply_filters_for_has_one_attr(scope, attr_name, class_name, params, current_user: current_user)
+          end
+          scope
+        end
+
+        def apply_filters_for_has_one_attr(scope, attr_name, filters_class_name, params, current_user: nil)
+
+          # Model of the nested filters
+          model_class_name = filters_class_name.delete_suffix("::Filters")
+          model_class = model_class_name.constantize
+
+          # Exact match on the referenced object ID
+          unless params[attr_name].blank?
+            scope = scope.joins(attr_name.to_sym) # presume the "belongs_to" or "has_one" relation is named same as the filter attribute
+            scope = scope.where("#{model_class.table_name}.id = ?", params[attr_name])
+          end
+
+          # Collect nested params applicable for the nested filters
+          nested_params = {}
+          model_class.permitted_filter_params.each do |nested_attr_name|
+            param_key = :"#{attr_name}__#{nested_attr_name}"
+            unless params[param_key].blank?
+              nested_params[nested_attr_name] = params[param_key]
+            end
+          end
+
+          # Apply nested filters, we can join one level deep only for now
+          unless nested_params.empty?
+            scope = scope.joins(attr_name.to_sym) # presume the "belongs_to" or "has_one" relation is named same as the filter attribute
+            scope = model_class.apply_filters(scope, nested_params, parent: attr_name.to_sym, current_user: current_user)
+          end
+          scope
+        rescue NameError
+          scope
+        end
+
+        def apply_filters_for_range_attrs(scope, params, prefix: '')
+          return scope unless is_filters_model?(filters_model_class)
+          filters_model_class.range_attrs.each do |attr_spec|
+            next if filters_model_class.has_filter_attr?(attr_spec[:attr_name])
+            attr_name = attr_spec[:attr_name]
+            lower_attr_name = attr_spec[:lower_attr_name]
+            upper_attr_name = attr_spec[:upper_attr_name]
+
+            # Exact match
+            unless params[attr_name].blank?
+              value = begin
+                filters_model_class.clean_range_value(params[attr_name], attr_name)
+              rescue Eluvia::Errors::StandardError
+                raise Eluvia::Errors::UnprocessableEntity.new({
+                  "#{prefix}#{attr_name}" => I18n.t('eluvia.errors.filter.invalid_value_format',
+                    default: 'Invalid value format.')
+                })
+              end
+              if value
+                if value[:lower]
+                  scope = scope.where("#{self.table_name}.#{lower_attr_name} = ?", value[:lower])
+                else
+                  scope = scope.where("#{self.table_name}.#{lower_attr_name} IS NULL")
+                end
+                if value[:upper]
+                  scope = scope.where("#{self.table_name}.#{upper_attr_name} = ?", value[:upper])
+                else
+                  scope = scope.where("#{self.table_name}.#{upper_attr_name} IS NULL")
+                end
+              end
+            end
+
+            # Overlap match
+            attr_name_overlap = :"#{attr_name}__overlap"
+            unless params[attr_name_overlap].blank?
+              value = begin
+                filters_model_class.clean_range_value(params[attr_name_overlap], attr_name)
+              rescue Eluvia::Errors::StandardError
+                raise Eluvia::Errors::UnprocessableEntity.new({
+                  "#{prefix}#{attr_name_overlap}" => I18n.t('eluvia.errors.filter.invalid_value_format',
+                    default: 'Invalid value format.')
+                })
+              end
+              if value
+                if value[:lower]
+                  scope = scope.where("(#{self.table_name}.#{upper_attr_name} IS NULL OR #{self.table_name}.#{upper_attr_name} >= ?)", value[:lower])
+                end
+                if value[:upper]
+                  scope = scope.where("(#{self.table_name}.#{lower_attr_name} IS NULL OR #{self.table_name}.#{lower_attr_name} <= ?)", value[:upper])
+                end
+              end
+            end
+
+          end
+          scope
+        end
+
+        def apply_filters_for_uuid_attrs(scope, params, prefix: '')
+          return scope unless is_filters_model?(filters_model_class)
+          filters_model_class.attrs(type: :uuid).each do |attr_spec|
+            next if filters_model_class.has_filter_attr?(attr_spec[:attr_name])
+            attr_name = attr_spec[:attr_name]
+            underlying_attr_name = attr_spec[:underlying_attr_name] || attr_name
+
+            # Exact match
+            unless params[attr_name].blank?
+              unless params[attr_name].to_s.match?(UUID_FORMAT)
+                raise Eluvia::Errors::UnprocessableEntity.new({
+                  "#{prefix}#{attr_name}" => I18n.t('eluvia.errors.filter.invalid_uuid_format',
+                    default: 'Invalid UUID format.')
+                })
+              end
+              scope = scope.where("#{self.table_name}.#{underlying_attr_name} = ?", filters_model_class.clean_and_transform_value(params[attr_name], attr_name))
+            end
+
+            # In match
+            attr_name_in = :"#{attr_name}__in"
+            unless params[attr_name_in].nil? # we want to support empty array as well
+              values = params[attr_name_in]
+              values = values.to_s.split(',') unless values.is_a?(Array)
+              values.each do |v|
+                unless v.to_s.match?(UUID_FORMAT)
+                  raise Eluvia::Errors::UnprocessableEntity.new({
+                    "#{prefix}#{attr_name_in}" => I18n.t('eluvia.errors.filter.invalid_uuid_format',
+                      default: 'Invalid UUID format.')
+                  })
+                end
+              end
+              scope = scope.where("#{self.table_name}.#{underlying_attr_name}" => values.map { |v| filters_model_class.clean_and_transform_value(v, attr_name) })
+            end
+          end
+          scope
+        end
+
+        def apply_filters_for_string_attrs(scope, params)
+          return scope unless is_filters_model?(filters_model_class)
+          filters_model_class.attrs(type: :string).each do |attr_spec|
+            next if filters_model_class.has_filter_attr?(attr_spec[:attr_name])
+            attr_name = attr_spec[:attr_name]
+            underlying_attr_name = attr_spec[:underlying_attr_name] || attr_name
+
+            # Exact match
+            unless params[attr_name].blank?
+              scope = scope.where("#{self.table_name}.#{underlying_attr_name} = ?", filters_model_class.clean_and_transform_value(params[attr_name], attr_name))
+            end
+
+            # Greater than or equal match
+            attr_name_gte = :"#{attr_name}__gte"
+            unless params[attr_name_gte].blank?
+              scope = scope.where("#{self.table_name}.#{underlying_attr_name} >= ?", filters_model_class.clean_and_transform_value(params[attr_name_gte], attr_name))
+            end
+
+            # Greater than match
+            attr_name_gt = :"#{attr_name}__gt"
+            unless params[attr_name_gt].blank?
+              scope = scope.where("#{self.table_name}.#{underlying_attr_name} > ?", filters_model_class.clean_and_transform_value(params[attr_name_gt], attr_name))
+            end
+
+            # Less than or equal match
+            attr_name_lte = :"#{attr_name}__lte"
+            unless params[attr_name_lte].blank?
+              scope = scope.where("#{self.table_name}.#{underlying_attr_name} <= ?", filters_model_class.clean_and_transform_value(params[attr_name_lte], attr_name))
+            end
+
+            # Less than match
+            attr_name_lt = :"#{attr_name}__lt"
+            unless params[attr_name_lt].blank?
+              scope = scope.where("#{self.table_name}.#{underlying_attr_name} < ?", filters_model_class.clean_and_transform_value(params[attr_name_lt], attr_name))
+            end
+
+            # Icontains match
+            attr_name_icontains = :"#{attr_name}__icontains"
+            unless params[attr_name_icontains].blank?
+              scope = scope.where("lower(#{self.table_name}.#{underlying_attr_name}) LIKE ('%' || lower(trim(?)) || '%')",
+filters_model_class.clean_and_transform_value(params[attr_name_icontains], attr_name))
+            end
+
+            # In match
+            attr_name_in = :"#{attr_name}__in"
+            unless params[attr_name_in].nil? # we want to support empty array as well
+              values = params[attr_name_in]
+              values = values.to_s.split(',') unless values.is_a?(Array)
+              scope = scope.where("#{self.table_name}.#{underlying_attr_name}" => values.map { |v| filters_model_class.clean_and_transform_value(v, attr_name) })
+            end
+          end
+          scope
+        end
+
+        def apply_filters_for_integer_attrs(scope, params, prefix: '')
+          return scope unless is_filters_model?(filters_model_class)
+          filters_model_class.attrs(type: :integer).each do |attr_spec|
+            next if filters_model_class.has_filter_attr?(attr_spec[:attr_name])
+            attr_name = attr_spec[:attr_name]
+            underlying_attr_name = attr_spec[:underlying_attr_name] || attr_name
+
+            [
+              [attr_name, "#{self.table_name}.#{underlying_attr_name} = ?"],
+              [:"#{attr_name}__gte", "#{self.table_name}.#{underlying_attr_name} >= ?"],
+              [:"#{attr_name}__gt", "#{self.table_name}.#{underlying_attr_name} > ?"],
+              [:"#{attr_name}__lte", "#{self.table_name}.#{underlying_attr_name} <= ?"],
+              [:"#{attr_name}__lt", "#{self.table_name}.#{underlying_attr_name} < ?"],
+            ].each do |param_key, condition|
+              next if params[param_key].blank?
+              unless params[param_key].to_s.match?(/\A-?\d+\z/)
+                raise Eluvia::Errors::UnprocessableEntity.new({
+                  "#{prefix}#{param_key}" => I18n.t('eluvia.errors.filter.invalid_integer_format',
+                    default: 'Invalid integer format.')
+                })
+              end
+              scope = scope.where(condition, filters_model_class.clean_and_transform_value(params[param_key], attr_name))
+            end
+
+          end
+          scope
+        end
+
+        def apply_filters_for_date_attrs(scope, params, prefix: '')
+          return scope unless is_filters_model?(filters_model_class)
+          filters_model_class.attrs(type: :date).each do |attr_spec|
+            next if filters_model_class.has_filter_attr?(attr_spec[:attr_name])
+            attr_name = attr_spec[:attr_name]
+            underlying_attr_name = attr_spec[:underlying_attr_name] || attr_name
+
+            [
+              [attr_name, "#{self.table_name}.#{underlying_attr_name} = ?"],
+              [:"#{attr_name}__from", "#{self.table_name}.#{underlying_attr_name} >= ?"],
+              [:"#{attr_name}__to", "#{self.table_name}.#{underlying_attr_name} <= ?"],
+            ].each do |param_key, condition|
+              next if params[param_key].blank?
+              value = filters_model_class.clean_and_transform_value(params[param_key], attr_name)
+              msg = I18n.t('eluvia.errors.filter.invalid_date_format', default: 'Invalid date format.')
+              raise Eluvia::Errors::UnprocessableEntity.new({ "#{prefix}#{param_key}" => msg }) if value.nil?
+              scope = scope.where(condition, value)
+            end
+
+          end
+          scope
+        end
+
+        def apply_filters_for_boolean_attrs(scope, params)
+          return scope unless is_filters_model?(filters_model_class)
+          filters_model_class.attrs(type: :boolean).each do |attr_spec|
+            next if filters_model_class.has_filter_attr?(attr_spec[:attr_name])
+            attr_name = attr_spec[:attr_name]
+            underlying_attr_name = attr_spec[:underlying_attr_name] || attr_name
+
+            # Boolean match
+            unless params[attr_name].nil?
+              if filters_model_class.clean_value(params[attr_name], attr_name)
+                scope = scope.where("#{self.table_name}.#{underlying_attr_name} = ?", true)
+              else
+                scope = scope.where("#{self.table_name}.#{underlying_attr_name} IS NULL OR #{self.table_name}.#{attr_name} = ?", false)
+              end
+            end
+
+          end
+          scope
+        end
+
+        def _filters_model_class
+          filters_model_class_name = "#{self.name}::Filters"
+          filters_model_class_name.constantize
+        rescue NameError
+          nil
+        end
+
+        def filters_model_class
+          @filters_model_class ||= _filters_model_class
+        end
+
+        def is_filters_model?(model)
+          return false if model.nil?
+          return false unless model.respond_to?(:ancestors)
+          model.ancestors.include?(Eluvia::ActiveRecord::FiltersModel)
+        end
+
+      end
+    end
+  end
+end