lcp 0.1.0

data/lib/lcp_ruby/search/parameter_definition.rb

@@ -0,0 +1,187 @@
+module LcpRuby
+  module Search
+    class ParameterDefinition
+      VALID_TYPES = %w[enum_select association_select boolean_select number_range date_range].freeze
+
+      SELECT_TYPES = %w[enum_select association_select boolean_select].freeze
+      RANGE_TYPES = %w[number_range date_range].freeze
+
+      attr_reader :name, :type, :field, :model, :options, :label_key,
+                  :visible_when, :search, :min_query_length, :per_page, :label_method,
+                  :include_blank, :col_span
+
+      def initialize(name:, type:, field:, model: nil, options: nil, label_key: nil,
+                     visible_when: nil, search: nil, min_query_length: nil, per_page: nil,
+                     label_method: nil, include_blank: nil, col_span: nil)
+        @name = name.to_s
+        @type = type.to_s
+        @field = field.to_s
+        @model = model&.to_s
+        @options = options
+        @label_key = label_key&.to_s
+        @visible_when = visible_when
+        @search = search
+        @min_query_length = min_query_length
+        @per_page = per_page
+        @label_method = label_method&.to_s
+        @include_blank = include_blank
+        @col_span = col_span
+
+        validate!
+      end
+
+      def self.from_hash(hash)
+        hash = HashUtils.stringify_deep(hash)
+        new(
+          name: hash["name"],
+          type: hash["type"],
+          field: hash["field"],
+          model: hash["model"],
+          options: hash["options"],
+          label_key: hash["label_key"],
+          visible_when: hash["visible_when"],
+          search: hash["search"],
+          min_query_length: hash["min_query_length"],
+          per_page: hash["per_page"],
+          label_method: hash["label_method"],
+          include_blank: hash["include_blank"],
+          col_span: hash["col_span"]
+        )
+      end
+
+      def select_type?
+        SELECT_TYPES.include?(@type)
+      end
+
+      def range_type?
+        RANGE_TYPES.include?(@type)
+      end
+
+      def enum_select?
+        @type == "enum_select"
+      end
+
+      def association_select?
+        @type == "association_select"
+      end
+
+      def boolean_select?
+        @type == "boolean_select"
+      end
+
+      def number_range?
+        @type == "number_range"
+      end
+
+      def date_range?
+        @type == "date_range"
+      end
+
+      def remote_search?
+        !!@search
+      end
+
+      def effective_col_span(grid_columns)
+        return @col_span if @col_span
+        return 2 if range_type? && grid_columns >= 2
+        nil
+      end
+
+      def visible_for_user?(user)
+        return true unless @visible_when.is_a?(Hash) && @visible_when["role"].present?
+        return false unless user
+
+        (LcpRuby.user_roles(user) & Array(@visible_when["role"]).map(&:to_s)).any?
+      end
+
+      def blank_label
+        case @include_blank
+        when false then nil
+        when String then @include_blank
+        else I18n.t("lcp_ruby.parameters.all", default: "All")
+        end
+      end
+
+      def to_input_options
+        opts = {}
+        opts["search"] = true if @search
+        opts["label_method"] = @label_method if @label_method.present?
+        opts["per_page"] = @per_page if @per_page
+        opts["min_query_length"] = @min_query_length if @min_query_length
+        opts
+      end
+
+      def ransack_param_keys
+        if range_type?
+          [ "#{@field}_gteq", "#{@field}_lteq" ]
+        else
+          [ "#{@field}_eq" ]
+        end
+      end
+
+      def read_current_value(params_f)
+        return nil if params_f.blank?
+
+        if range_type?
+          from_val = params_f["#{@field}_gteq"]
+          to_val = params_f["#{@field}_lteq"]
+          (from_val.present? || to_val.present?) ? { from: from_val, to: to_val } : nil
+        else
+          params_f["#{@field}_eq"]
+        end
+      end
+
+      def label
+        if @label_key.present?
+          I18n.t(@label_key, default: @name.humanize)
+        else
+          I18n.t("lcp_ruby.parameters.#{@name}", default: @name.humanize)
+        end
+      end
+
+      def auto_derive_options(model_definition)
+        if enum_select?
+          if @options.present?
+            @options.map { |opt| [ opt.to_s.humanize, opt.to_s ] }
+          else
+            field_def = model_definition.fields.find { |f| f.name == @field }
+            return [] unless field_def&.enum?
+
+            model_name = model_definition.name
+            field_def.enum_value_names.map { |val|
+              [ field_def.enum_label_for(val, model_name: model_name), val ]
+            }
+          end
+        elsif boolean_select?
+          [
+            [ I18n.t("lcp_ruby.parameters.boolean.yes", default: "Yes"), "true" ],
+            [ I18n.t("lcp_ruby.parameters.boolean.no", default: "No"), "false" ]
+          ]
+        else
+          []
+        end
+      end
+
+      private
+
+      def validate!
+        raise MetadataError, "Parameter name is required" if @name.blank?
+        raise MetadataError, "Parameter '#{@name}': field is required" if @field.blank?
+
+        unless VALID_TYPES.include?(@type)
+          raise MetadataError, "Parameter '#{@name}' has invalid type '#{@type}'. " \
+                               "Must be one of: #{VALID_TYPES.join(', ')}"
+        end
+
+        if @visible_when.is_a?(Hash) && @visible_when.keys.map(&:to_s) != [ "role" ]
+          raise MetadataError, "Parameter '#{@name}': visible_when supports only the 'role' key " \
+                               "(condition-based evaluation is not available on index pages)"
+        end
+
+        if @search && @type != "association_select"
+          raise MetadataError, "Parameter '#{@name}': 'search' option is only valid for association_select type"
+        end
+      end
+    end
+  end
+end

data/lib/lcp_ruby/search/parameterized_scope_applicator.rb

@@ -0,0 +1,129 @@
+module LcpRuby
+  module Search
+    class ParameterizedScopeApplicator
+      # Applies parameterized scopes from request params to a query scope.
+      #
+      # @param scope [ActiveRecord::Relation] the current query scope
+      # @param scope_params [Hash] raw params hash, e.g. { "created_recently" => { "days" => "30" } }
+      # @param model_class [Class] the AR model class
+      # @param model_definition [Metadata::ModelDefinition]
+      # @param evaluator [Authorization::PermissionEvaluator]
+      # @return [ActiveRecord::Relation]
+      def self.apply(scope, scope_params, model_class, model_definition, evaluator:)
+        return scope if scope_params.blank?
+
+        scope_params.each do |scope_name, raw_params|
+          scope_config = model_definition.parameterized_scope(scope_name)
+          next unless scope_config
+
+          raw_params = raw_params.to_unsafe_h if raw_params.respond_to?(:to_unsafe_h)
+          raw_params = {} unless raw_params.is_a?(Hash)
+
+          parameters = scope_config["parameters"] || []
+          cast_params = cast_parameters(parameters, raw_params)
+
+          # Skip if required params are missing
+          next if missing_required?(parameters, cast_params)
+
+          # Try filter_* interceptor first, then direct scope
+          interceptor = "filter_#{scope_name}"
+          if model_class.respond_to?(interceptor)
+            scope = model_class.send(interceptor, scope, cast_params, evaluator)
+          elsif model_class.respond_to?(scope_name)
+            scope = invoke_scope(scope, scope_name, cast_params)
+          else
+            Rails.logger.warn(
+              "[LcpRuby::ParameterizedScopeApplicator] Scope '#{scope_name}' " \
+              "not found on model #{model_class.name}"
+            )
+          end
+        end
+
+        scope
+      end
+
+      # Casts raw string params according to parameter type definitions.
+      # @param parameters [Array<Hash>] parameter definitions from YAML
+      # @param raw_params [Hash] raw string params from request
+      # @return [Hash] cast params with symbolized keys
+      def self.cast_parameters(parameters, raw_params)
+        result = {}
+
+        parameters.each do |param_def|
+          param_def = param_def.transform_keys(&:to_s) if param_def.is_a?(Hash)
+          name = param_def["name"]
+          type = param_def["type"]
+          raw_value = raw_params[name] || raw_params[name.to_sym]
+
+          if raw_value.nil?
+            default = param_def["default"]
+            result[name.to_sym] = default unless default.nil?
+            next
+          end
+
+          cast = cast_value(raw_value, type, param_def)
+          result[name.to_sym] = cast unless cast.nil?
+        end
+
+        result
+      end
+      private_class_method :cast_parameters
+
+      def self.cast_value(raw, type, param_def)
+        case type
+        when "integer"
+          val = raw.to_i
+          val = clamp_numeric(val, param_def)
+          val
+        when "float", "decimal"
+          val = raw.to_f
+          val = clamp_numeric(val, param_def)
+          val
+        when "string"
+          raw.to_s
+        when "boolean"
+          %w[true 1 yes].include?(raw.to_s.downcase)
+        when "date"
+          Date.parse(raw.to_s)
+        when "datetime"
+          DateTime.parse(raw.to_s)
+        when "enum"
+          values = Array(param_def["values"]).map(&:to_s)
+          raw_str = raw.to_s
+          values.include?(raw_str) ? raw_str : nil
+        when "model_select"
+          raw.to_i
+        end
+      rescue ArgumentError, TypeError
+        nil
+      end
+      private_class_method :cast_value
+
+      def self.clamp_numeric(val, param_def)
+        min = param_def["min"]
+        max = param_def["max"]
+        val = [ val, min ].max if min
+        val = [ val, max ].min if max
+        val
+      end
+      private_class_method :clamp_numeric
+
+      def self.missing_required?(parameters, cast_params)
+        parameters.any? do |param_def|
+          param_def = param_def.transform_keys(&:to_s) if param_def.is_a?(Hash)
+          param_def["required"] == true && !cast_params.key?(param_def["name"].to_sym)
+        end
+      end
+      private_class_method :missing_required?
+
+      def self.invoke_scope(scope, scope_name, cast_params)
+        if cast_params.any?
+          scope.send(scope_name, **cast_params)
+        else
+          scope.send(scope_name)
+        end
+      end
+      private_class_method :invoke_scope
+    end
+  end
+end

data/lib/lcp_ruby/search/query_builder.rb

@@ -0,0 +1,143 @@
+module LcpRuby
+  module Search
+    # Reusable search pipeline extracted from ApplicationController#apply_advanced_search.
+    # Used by the export handler and other non-controller contexts that need to reconstruct
+    # the same query from filter params.
+    #
+    # Handles: default scope, predefined filters, parameterized scopes, Ransack filters,
+    # quick search, and custom field filters. Does NOT handle saved filters (those require
+    # additional visibility checks and controller-level side effects).
+    class QueryBuilder
+      Result = Struct.new(:scope, :ransack_search, keyword_init: true)
+
+      # @param scope [ActiveRecord::Relation] base scope (already policy-scoped)
+      # @param params [Hash] search params with string keys: "f", "qs", "cf", "filter", "scope"
+      # @param model_class [Class] the AR model class
+      # @param model_definition [Metadata::ModelDefinition]
+      # @param presenter [Metadata::PresenterDefinition]
+      # @param evaluator [Authorization::PermissionEvaluator]
+      # @return [Result] with :scope and :ransack_search
+      def self.apply(scope, params:, model_class:, model_definition:, presenter:, evaluator:)
+        new(scope, params, model_class, model_definition, presenter, evaluator).apply
+      end
+
+      def initialize(scope, params, model_class, model_definition, presenter, evaluator)
+        @scope = scope
+        @params = params.transform_keys(&:to_s)
+        @model_class = model_class
+        @model_definition = model_definition
+        @presenter = presenter
+        @evaluator = evaluator
+        @ransack_search = nil
+      end
+
+      def apply
+        search_config = @presenter.search_config
+        return Result.new(scope: @scope, ransack_search: nil) unless search_config["enabled"]
+
+        apply_default_scope(search_config)
+        apply_predefined_filter(search_config)
+        apply_parameterized_scopes
+        apply_ransack_filters(search_config)
+        apply_quick_search(search_config)
+        apply_custom_field_filters
+
+        Result.new(scope: @scope, ransack_search: @ransack_search)
+      end
+
+      private
+
+      def apply_default_scope(search_config)
+        scope_name = search_config["default_scope"]
+        return unless scope_name
+
+        @scope = @scope.send(scope_name) if @model_class.respond_to?(scope_name)
+      end
+
+      def apply_predefined_filter(search_config)
+        filter_name = @params["filter"]
+        return unless filter_name.present?
+
+        predefined = search_config["predefined_filters"]&.find { |f| f["name"] == filter_name }
+        scope_name = predefined&.dig("scope")
+        @scope = @scope.send(scope_name) if scope_name && @model_class.respond_to?(scope_name)
+      end
+
+      def apply_parameterized_scopes
+        scope_params = @params["scope"]
+        return unless scope_params.present?
+
+        scope_hash = scope_params.is_a?(Hash) ? scope_params : scope_params.to_unsafe_h
+        @scope = ParameterizedScopeApplicator.apply(
+          @scope, scope_hash, @model_class, @model_definition,
+          evaluator: @evaluator
+        )
+      end
+
+      def apply_ransack_filters(search_config)
+        raw_filter_params = ParamSanitizer.reject_blanks(
+          @params["f"].is_a?(Hash) ? @params["f"] : @params["f"]&.to_unsafe_h
+        )
+
+        max_conditions = @presenter.advanced_filter_config["max_conditions"] || 10
+        if raw_filter_params.is_a?(Hash) && raw_filter_params.size > max_conditions
+          raw_filter_params = raw_filter_params.first(max_conditions).to_h
+        end
+
+        raw_filter_params = RelativeDateExpander.expand(raw_filter_params) if raw_filter_params.present?
+
+        if raw_filter_params.present?
+          @scope, remaining_params = CustomFilterInterceptor.apply(
+            @scope, raw_filter_params, @model_class, @evaluator
+          )
+        else
+          remaining_params = {}
+        end
+
+        if remaining_params.present?
+          @ransack_search = @model_class.ransack(remaining_params, auth_object: @evaluator)
+          @scope = @scope.merge(@ransack_search.result(distinct: true))
+        end
+      end
+
+      def apply_quick_search(search_config)
+        qs = @params["qs"]
+        searchable_fields = search_config["searchable_fields"]
+        return unless qs.present? && searchable_fields&.any?
+
+        @scope = QuickSearch.apply(
+          @scope, qs, @model_class, @model_definition,
+          searchable_field_names: searchable_fields
+        )
+      end
+
+      def apply_custom_field_filters
+        cf_params = @params["cf"]
+        return unless cf_params.present? && @model_definition.custom_fields_enabled?
+
+        definitions = CustomFields::Registry.for_model(@model_definition.name)
+        return if definitions.empty?
+
+        filterable_defs = definitions.select { |d| d.active && d.respond_to?(:filterable) && d.filterable }
+        defs_by_name = filterable_defs.index_by(&:field_name)
+        sorted_names = defs_by_name.keys.sort_by { |n| -n.length }
+        table_name = @model_class.table_name
+
+        cf_hash = cf_params.is_a?(Hash) ? cf_params : cf_params.to_unsafe_h
+        cf_hash.each do |key, value|
+          next if value.is_a?(String) && value.blank?
+
+          field_name, operator = CustomFieldFilter.parse_cf_key(key, sorted_names)
+          next unless field_name
+
+          defn = defs_by_name[field_name]
+          next unless defn
+          next unless @evaluator.field_readable?(field_name)
+
+          cast = CustomFieldFilter.cast_for_type(defn.custom_type)
+          @scope = CustomFieldFilter.apply(@scope, table_name, field_name, operator, value, cast: cast)
+        end
+      end
+    end
+  end
+end