refine-rails 2.9.0

data/app/models/refine/conditions/has_meta.rb

@@ -0,0 +1,10 @@
+module Refine::Conditions::HasMeta
+  def meta
+    @meta ||= {}
+  end
+
+  def with_meta(value)
+    meta.merge!(value)
+    self
+  end
+end

data/app/models/refine/conditions/has_refinements.rb

@@ -0,0 +1,156 @@
+module Refine::Conditions
+  module HasRefinements
+    def refine_by_filter(filter_condition)
+      @filter_refinement_proc = proc { filter_condition }
+      self
+    end
+
+    def refine_by_date(callable = nil)
+      # Developer can send in a string that represents the attribute or a proc that is a fully qualified class
+      # If a callable is given and it is a string, we assume that is the desired attribute. Otherwise we use
+      # the passed in callable. If no callable is given we create on based on standard date with time condition
+      @date_refinement_proc = if callable.present?
+        (callable.is_a? String) ? define_date_condition(attribute: callable) : callable
+      else
+        define_date_condition(attribute: "created_at")
+      end
+      self
+    end
+
+    def define_date_condition(attribute:)
+      proc { DateCondition.new("date_refinement").with_attribute(attribute).attribute_is_date_with_time }
+    end
+
+    def refine_by_count(callable = nil)
+      @count_refinement_proc = callable.present? ? callable : define_count_condition
+      self
+    end
+
+    def define_count_condition
+      proc { NumericCondition.new("count_refinement") }
+    end
+
+    def apply_refinements(input)
+      if has_any_refinements? && !refinements_allowed?
+        raise Errors::RelationshipError, I18n.t("refine.refine_blueprints.has_refinements.not_allowed")
+      end
+
+      instance = filter.get_pending_relationship_instance
+
+      subquery_table = instance.klass.arel_table
+      subquery = filter.get_pending_relationship_subquery
+
+      if @date_refinement_proc
+        nodes = apply_date_refinement(subquery_table, input[:date_refinement])
+      end
+      if @count_refinement_proc
+        apply_count_refinement(table: subquery_table, input: input[:count_refinement], subquery: subquery, instance: instance)
+      end
+      nodes
+    end
+
+    def has_any_refinements?
+      !!(has_date_refinement? || has_count_refinement?)
+    end
+
+    def has_count_refinement?
+      @count_refinement_proc
+    end
+
+    def has_date_refinement?
+      @date_refinement_proc
+    end
+
+    def refinements_allowed?
+      instance = filter.get_pending_relationship_instance
+      (instance.is_a? ActiveRecord::Reflection::HasManyReflection) || (instance.is_a? ActiveRecord::Reflection::ThroughReflection)
+    end
+
+    def apply_date_refinement(table, input)
+      get_date_refinement_condition.apply(input, table, nil)
+    end
+
+    def apply_count_refinement(table:, input:, subquery:, instance:)
+      condition = get_count_refinement_condition
+      # We need to group by because we're going to be using a `having`
+      # to get the count of records. Since we're using a where in for this
+      # relationship subquery, we're only selecting the foreign key,
+      # so we'll just group by that too.
+      subquery.group(table[instance.foreign_key])
+
+      # If user's input doesn't include the number 0, there is no complicated
+      # joining
+      if condition.input_could_include_zero?(input)
+        # if the input DOES include 0 then we have to do a bit of extra work. If you were trying to get a list of
+        # contacts that has i.e. 0 events, you can't query the events table b/c those contacts
+        # don't have any record there.
+        # Get a list of all contacts, left join in the count of events we're looking for, and coalesce nulls
+        # to 0. That gives us a true count for every contact, even if the count is 0. Then we can use
+        # the Numeric Condition as usual.
+        # Wrap the existing subquery - subquery is an AREL Select manager and modified in place
+        subquery.project((Arel.star.count).as("hs_refine_count_aggregate"))
+
+        # The table that owns the relationship
+        # TODO This is redundant
+        parent_table = instance.active_record.arel_table
+        parent_primary_key = instance.active_record.primary_key
+
+        # SELECT "contacts"."id" FROM "contacts"
+        outer_query = parent_table.project(parent_table[parent_primary_key.to_sym])
+
+        callable_subquery =
+          proc do |inner_query, primary_key, foreign_key|
+            interim_table = inner_query.as("interim_table")
+            outer_query.join(interim_table, Arel::Nodes::OuterJoin).on(interim_table[foreign_key.to_sym].eq(parent_table[primary_key.to_sym]))
+          end
+
+        filter.set_pending_relationship_subquery_wrapper(callable_subquery)
+
+        condition.raw_attribute("coalesce(hs_refine_count_aggregate, 0)")
+
+        node = condition.apply(input, table, nil)
+        outer_query.where(node)
+      else
+        node = condition.apply(input, table, nil)
+        # Modify the pending relationship subquery in place to be applied later
+        # Remember, AREL in this instance has passed by reference so pending_relationship_subquery will be modified
+        subquery.having(node)
+        # Return nil case due to pending relationship subquery not yet being applied
+        nil
+      end
+    end
+
+    def get_date_refinement_condition
+      # Create the condition from the callable
+      condition = @date_refinement_proc.call
+      # Overwrite any passed in id's with date_refinement
+      condition.id = "date_refinement"
+      condition.is_refinement = true
+      filter.instantiate_condition(condition)
+    end
+
+    def get_count_refinement_condition
+      condition = @count_refinement_proc.call
+      # Overwrite any passed in id's with count_refinement
+      condition.id = "count_refinement"
+      condition.is_refinement = true
+      condition.raw_attribute("COUNT(*)")
+      filter.instantiate_condition(condition)
+    end
+
+    def refinements_to_array
+      if is_refinement
+        []
+      else
+        refinement_array = []
+        if @date_refinement_proc
+          refinement_array << get_date_refinement_condition.to_array
+        end
+        if @count_refinement_proc
+          refinement_array << get_count_refinement_condition.to_array
+        end
+        refinement_array
+      end
+    end
+  end
+end

data/app/models/refine/conditions/numeric_condition.rb

@@ -0,0 +1,224 @@
+module Refine::Conditions
+  class NumericCondition < Condition
+    include ActiveModel::Validations
+    include HasClauses
+
+    cattr_accessor :default_clause_display_map, default: {}, instance_accessor: false
+
+    validates :value1, numericality: true, allow_nil: true
+    validates :value2, numericality: true, allow_nil: true
+
+    with_options if: :floats_not_allowed? do
+      validates :value1, numericality: {only_integer: true}, allow_nil: true
+      validates :value2, numericality: {only_integer: true}, allow_nil: true
+    end
+
+    attr_reader :value1, :value2
+
+    CLAUSE_EQUALS = Clauses::EQUALS
+    CLAUSE_DOESNT_EQUAL = Clauses::DOESNT_EQUAL
+
+    CLAUSE_LESS_THAN_OR_EQUAL = Clauses::LESS_THAN_OR_EQUAL
+    CLAUSE_LESS_THAN = Clauses::LESS_THAN
+    CLAUSE_GREATER_THAN = Clauses::GREATER_THAN
+    CLAUSE_GREATER_THAN_OR_EQUAL = Clauses::GREATER_THAN_OR_EQUAL
+
+    CLAUSE_BETWEEN = Clauses::BETWEEN
+    CLAUSE_NOT_BETWEEN = Clauses::NOT_BETWEEN
+
+    CLAUSE_SET = Clauses::SET
+    CLAUSE_NOT_SET = Clauses::NOT_SET
+
+    I18N_PREFIX = "refine.refine_blueprints.numeric_condition."
+
+    def boot
+      @floats = false
+    end
+
+    def set_input_parameters(input)
+      @value1 = input[:value1]
+      @value2 = input[:value2]
+    end
+
+    def component
+      "numeric-condition"
+    end
+
+    def human_readable(input)
+      current_clause = get_clause_by_id(input[:clause])
+      case input[:clause]
+      when *[CLAUSE_EQUALS, CLAUSE_DOESNT_EQUAL, CLAUSE_GREATER_THAN, CLAUSE_GREATER_THAN_OR_EQUAL, CLAUSE_LESS_THAN, CLAUSE_LESS_THAN_OR_EQUAL]
+        "#{display} #{current_clause.display} #{input[:value1]}"
+      when *[CLAUSE_BETWEEN, CLAUSE_NOT_BETWEEN]
+        "#{display} #{current_clause.display} #{input[:value1]} #{I18n.t("#{I18N_PREFIX}and")} #{input[:value2]}"
+      when *[CLAUSE_SET, CLAUSE_NOT_SET]
+        "#{display} #{current_clause.display}"
+      else
+        raise "#{input[:clause]} #{I18n.t("#{I18N_PREFIX}not_supported")}"
+      end
+    end
+
+    def human_readable_value(input)
+      current_clause = get_clause_by_id(input[:clause])
+      case input[:clause]
+      when *[CLAUSE_EQUALS, CLAUSE_DOESNT_EQUAL, CLAUSE_GREATER_THAN, CLAUSE_GREATER_THAN_OR_EQUAL, CLAUSE_LESS_THAN, CLAUSE_LESS_THAN_OR_EQUAL]
+        input[:value1]
+      when *[CLAUSE_BETWEEN, CLAUSE_NOT_BETWEEN]
+        "#{input[:value1]} #{I18n.t("#{I18N_PREFIX}and")} #{input[:value2]}"
+      when *[CLAUSE_SET, CLAUSE_NOT_SET]
+        ""
+      else
+        raise "#{input[:clause]} #{I18n.t("#{I18N_PREFIX}not_supported")}"
+      end
+    end
+
+
+
+    def clauses
+      [
+        Clause.new(CLAUSE_EQUALS, I18n.t("#{I18N_PREFIX}is")).requires_inputs(["value1"]),
+
+        Clause.new(CLAUSE_DOESNT_EQUAL, I18n.t("#{I18N_PREFIX}is_not")).requires_inputs(["value1"]),
+
+        Clause.new(CLAUSE_GREATER_THAN, I18n.t("#{I18N_PREFIX}is_gt")).requires_inputs(["value1"]),
+
+        Clause.new(CLAUSE_GREATER_THAN_OR_EQUAL, I18n.t("#{I18N_PREFIX}is_gtteq")).requires_inputs(["value1"]),
+
+        Clause.new(CLAUSE_LESS_THAN, I18n.t("#{I18N_PREFIX}is_lt")).requires_inputs(["value1"]),
+
+        Clause.new(CLAUSE_LESS_THAN_OR_EQUAL, I18n.t("#{I18N_PREFIX}is_lteq")).requires_inputs(["value1"]),
+
+        Clause.new(CLAUSE_BETWEEN, I18n.t("#{I18N_PREFIX}is_between")).requires_inputs(["value1", "value2"]),
+
+        Clause.new(CLAUSE_NOT_BETWEEN, I18n.t("#{I18N_PREFIX}is_not_between")).requires_inputs(["value1", "value2"]),
+
+        Clause.new(CLAUSE_SET, I18n.t("#{I18N_PREFIX}is_set")),
+
+        Clause.new(CLAUSE_NOT_SET, I18n.t("#{I18N_PREFIX}is_not_set")),
+      ]
+    end
+
+    def allow_floats
+      @floats = true
+      self
+    end
+
+    def floats_not_allowed?
+      !@floats
+    end
+
+    # TODO Refactor to remove input here
+    def apply_condition(input, table, _inverse_clause)
+      # TODO check for custom clause
+
+      case clause
+      when CLAUSE_EQUALS
+        apply_clause_equals(table, value1)
+
+      when CLAUSE_DOESNT_EQUAL
+        apply_clause_doesnt_equal(table, value1)
+
+      when CLAUSE_GREATER_THAN
+        apply_clause_greater_than(table, value1)
+
+      when CLAUSE_GREATER_THAN_OR_EQUAL
+        apply_clause_greater_than_or_equal(table, value1)
+
+      when CLAUSE_LESS_THAN
+        apply_clause_less_than(table, value1)
+
+      when CLAUSE_LESS_THAN_OR_EQUAL
+        apply_clause_less_than_or_equal(table, value1)
+
+      when CLAUSE_BETWEEN
+        apply_clause_between(table, value1, value2)
+
+      when CLAUSE_NOT_BETWEEN
+        apply_clause_not_between(table, value1, value2)
+
+      when CLAUSE_SET
+        apply_clause_set(table)
+
+      when CLAUSE_NOT_SET
+        apply_clause_not_set(table)
+      end
+    end
+
+    def input_could_include_zero?(input)
+      clause = input[:clause]
+      value1 = input[:value1].to_i
+      value2 = input[:value2].to_i
+      case clause
+      when CLAUSE_EQUALS
+        return value1 == 0
+
+      when CLAUSE_DOESNT_EQUAL
+        return value1 != 0
+
+      when CLAUSE_LESS_THAN_OR_EQUAL
+        return value1 >= 0
+
+      when CLAUSE_LESS_THAN
+        return value1 > 0
+
+      when CLAUSE_GREATER_THAN
+        return value1 < 0
+
+      when CLAUSE_GREATER_THAN_OR_EQUAL
+        return value1 <= 0
+
+      when CLAUSE_BETWEEN
+        return value1 <= 0 && value2 >= 0
+
+      when CLAUSE_NOT_BETWEEN
+        return (value1 > 0 && value2 > 0) || (value1 < 0 && value2 < 0)
+
+      when CLAUSE_SET
+        return false
+
+      when CLAUSE_NOT_SET
+        return false
+      end
+    end
+
+    def apply_clause_equals(table, value)
+      table.grouping(arel_attribute(table).eq(value))
+    end
+
+    def apply_clause_doesnt_equal(table, value)
+      table.grouping(arel_attribute(table).not_eq(value).or(arel_attribute(table).eq(nil)))
+    end
+
+    def apply_clause_greater_than(table, value)
+      table.grouping(arel_attribute(table).gt(value))
+    end
+
+    def apply_clause_greater_than_or_equal(table, value)
+      table.grouping(arel_attribute(table).gteq(value))
+    end
+
+    def apply_clause_less_than(table, value)
+      table.grouping(arel_attribute(table).lt(value))
+    end
+
+    def apply_clause_less_than_or_equal(table, value)
+      table.grouping(arel_attribute(table).lteq(value))
+    end
+
+    def apply_clause_between(table, value1, value2)
+      table.grouping(arel_attribute(table).between(value1..value2))
+    end
+
+    def apply_clause_not_between(table, value1, value2)
+      table.grouping(arel_attribute(table).not_between(value1..value2))
+    end
+
+    def apply_clause_set(table)
+      table.grouping(arel_attribute(table).not_eq(nil))
+    end
+
+    def apply_clause_not_set(table)
+      table.grouping(arel_attribute(table).eq(nil))
+    end
+  end
+end

data/app/models/refine/conditions/option_condition.rb

@@ -0,0 +1,260 @@
+module Refine::Conditions
+  class OptionCondition < Condition
+    include HasClauses
+    include UsesAttributes
+    include ActiveModel::Validations
+
+    validate :select_is_array
+    validate :option_in_approved_list?
+
+    attr_reader :selected, :nil_option_id, :options
+
+    CLAUSE_EQUALS = Clauses::EQUALS
+    CLAUSE_DOESNT_EQUAL = Clauses::DOESNT_EQUAL
+
+    CLAUSE_IN = Clauses::IN
+    CLAUSE_NOT_IN = Clauses::NOT_IN
+
+    CLAUSE_SET = Clauses::SET
+    CLAUSE_NOT_SET = Clauses::NOT_SET
+
+    I18N_PREFIX = "refine.refine_blueprints.option_condition."
+
+    def component
+      "option-condition"
+    end
+
+    def human_readable(input)
+      current_clause = get_clause_by_id(input[:clause])
+      display_values = input[:selected]&.map {|option_id| get_options.call.find{|option| option[:id] == option_id}[:display]}.to_a
+      case input[:clause]
+      when *[CLAUSE_EQUALS, CLAUSE_DOESNT_EQUAL]
+        "#{display} #{current_clause.display} #{display_values.first}"
+      when *[CLAUSE_IN, CLAUSE_NOT_IN]
+        if display_values.length >= 3
+          display_values = display_values.take(2) + ["..."]
+        end
+        "#{display} #{current_clause.display}: #{display_values.join(", ")}"
+      when *[CLAUSE_SET, CLAUSE_NOT_SET]
+        "#{display} #{current_clause.display}"
+      else
+        raise "#{input[:clause]} #{I18n.t("#{I18N_PREFIX}not_supported")}"
+      end
+    end
+
+    def human_readable_value(input)
+      current_clause = get_clause_by_id(input[:clause])
+      display_values = input[:selected]&.map {|option_id| get_options.call.find{|option| option[:id] == option_id}[:display]}.to_a
+      case input[:clause]
+      when *[CLAUSE_EQUALS, CLAUSE_DOESNT_EQUAL]
+        display_values.first
+      when *[CLAUSE_IN, CLAUSE_NOT_IN]
+        if display_values.length >= 3
+          display_values = display_values.take(2) + ["..."]
+        end
+        display_values.join(", ")
+      when *[CLAUSE_SET, CLAUSE_NOT_SET]
+        ""
+      else
+        raise "#{input[:clause]} #{I18n.t("#{I18N_PREFIX}not_supported")}"
+      end
+    end
+
+    def boot
+      @nil_option_id = nil
+      @options = nil
+      # TODO @validate_selections = true
+      with_meta({options: get_options})
+      add_ensurance(ensure_options)
+    end
+
+    def set_input_parameters(input)
+      @selected = input[:selected]
+    end
+
+    def select_is_array
+      errors.add(:base, I18n.t("#{I18N_PREFIX}must_be_array")) unless selected.is_a?(Array)
+    end
+
+    def option_in_approved_list?
+      # TODO allow this to accept integers as well as strings. Right now must be a string.
+      return if selected.nil?
+      selected.each do |select|
+        select.join if select.is_a? Array
+        unless get_options.call.map { |option| option[:id] }.include? select
+          errors.add(:base, I18n.t("#{I18N_PREFIX}not_approved", select: select))
+        end
+      end
+    end
+
+    def get_options
+      proc do
+        @options = Refine::Rails.configuration.option_condition_ordering.call(
+          call_proc_if_callable(options)
+        )
+      end
+    end
+
+    def ensure_options
+      proc do
+        developer_options = get_options.call
+        # Options must be sent in as an array
+        if !developer_options.is_a? Array
+          raise I18n.t("#{I18N_PREFIX}not_determined")
+        end
+        # Each option must be a hash of values that includes :id and :display
+        developer_options.each do |option|
+          if (!option.is_a? Hash) || option.keys.exclude?(:id) || option.keys.exclude?(:display)
+            raise Refine::Conditions::Errors::OptionError.new(I18n.t("#{I18N_PREFIX}must_have_id_and_display"))
+          end
+        end
+        ensure_no_duplicates(developer_options)
+      end
+    end
+
+    def ensure_no_duplicates(developer_options)
+      id_array = developer_options.map { |option| option[:id] }
+      duplicates = id_array.select { |id| id_array.count(id) > 1 }.uniq
+      if duplicates.present?
+        raise Refine::Conditions::Errors::OptionError.new(I18n.t("#{I18N_PREFIX}must_be_unique", duplicates: duplicates))
+      end
+    end
+
+    def clauses
+      [
+        Clause.new(CLAUSE_EQUALS, I18n.t("#{I18N_PREFIX}is"))
+          .requires_inputs(["selected"])
+          .with_meta({multiple: false}),
+
+        Clause.new(CLAUSE_DOESNT_EQUAL, I18n.t("#{I18N_PREFIX}is_not"))
+          .requires_inputs(["selected"])
+          .with_meta({multiple: false}),
+
+        Clause.new(CLAUSE_IN, I18n.t("#{I18N_PREFIX}is_one_of"))
+          .requires_inputs(["selected"])
+          .with_meta({multiple: true}),
+
+        Clause.new(CLAUSE_NOT_IN, I18n.t("#{I18N_PREFIX}is_not_one_of"))
+          .requires_inputs(["selected"])
+          .with_meta({multiple: true}),
+
+        Clause.new(CLAUSE_SET, I18n.t("#{I18N_PREFIX}is_set")),
+
+        Clause.new(CLAUSE_NOT_SET, I18n.t("#{I18N_PREFIX}is_not_set"))
+      ]
+    end
+
+    def apply_condition(input, table, inverse_clause)
+      value = input[:selected]
+      # TODO: Triggers on "through" relationship. Other relationships?
+      @clause = CLAUSE_IN if inverse_clause
+
+      case clause
+      when CLAUSE_SET
+        apply_clause_set(table)
+
+      when CLAUSE_NOT_SET
+        apply_clause_not_set(table)
+
+      when CLAUSE_EQUALS
+        apply_clause_equals(value, table)
+
+      when CLAUSE_DOESNT_EQUAL
+        apply_clause_doesnt_equal(value, table)
+
+      when CLAUSE_IN
+        apply_clause_in(value, table)
+
+      when CLAUSE_NOT_IN
+        apply_clause_not_in(value, table)
+      end
+    end
+
+    def with_options(developer_configured_options)
+      @options = developer_configured_options
+      self
+    end
+
+    def with_nil_option(id)
+      @nil_option_id = id
+      self
+    end
+
+    def nil_option_selected?(value)
+      # Return false if no nil option id
+      return false unless nil_option_id
+      value&.include? nil_option_id
+    end
+
+    def values_for_application(ids, single = false)
+      # Get developer configured options with nil_option_id removed and select only elements from requested ids
+      # Extract values from either _value key or id key. _value can be a callable
+      values = get_options.call.delete_if { |el| el[:id] == nil_option_id }
+        .select { |value| ids.include? value[:id] }
+        .map! { |value| (value.has_key? :_value) ? call_proc_if_callable(value[:_value]) : value[:id] }
+      single ? values[0] : values
+    end
+
+    def apply_nil_query(value, table)
+      table.grouping(table[:"#{attribute}"].eq(nil))
+    end
+
+    def apply_not_nil_query(value, table)
+      table.grouping(table[:"#{attribute}"].not_eq(nil))
+    end
+
+    def apply_equals(value, table)
+      table.grouping(table[:"#{attribute}"].eq(value))
+    end
+
+    def apply_clause_in(value, table)
+      normalized_values = values_for_application(value)
+
+      if nil_option_selected?(value)
+        table.grouping(table[:"#{attribute}"].in(normalized_values).or(table[:"#{attribute}"].eq(nil)))
+      else
+        table.grouping(table[:"#{attribute}"].in(normalized_values))
+      end
+    end
+
+    def apply_clause_not_in(value, table)
+      normalized_values = values_for_application(value)
+      # Must check for only nil option selected here
+      if nil_option_selected?(value) && value.one?
+        table.grouping(table[:"#{attribute}"].not_eq(nil))
+      elsif nil_option_selected?(value)
+        table.grouping(table[:"#{attribute}"].not_in(normalized_values).or(table[:"#{attribute}"].not_eq(nil)))
+      else
+        table.grouping(table[:"#{attribute}"].not_in(normalized_values).or(table[:"#{attribute}"].eq(nil)))
+      end
+    end
+
+    def apply_clause_equals(value, table)
+      if nil_option_selected?(value)
+        apply_nil_query(value, table)
+      else
+        apply_equals(values_for_application(value, true), table)
+      end
+    end
+
+    def apply_clause_doesnt_equal(value, table)
+      if nil_option_selected?(value)
+        apply_not_nil_query(value, table)
+      else
+        apply_not_equals(values_for_application(value, true), table)
+      end
+    end
+
+    def apply_not_equals(value, table)
+      table.grouping(table[:"#{attribute}"].not_eq(value).or(table[:"#{attribute}"].eq(nil)))
+    end
+
+    def apply_clause_set(table)
+      table.grouping(table[:"#{attribute}"].not_eq_any([nil, ""]))
+    end
+
+    def apply_clause_not_set(table)
+      table.grouping(table[:"#{attribute}"].eq_any([nil, ""]))
+    end
+  end
+end