refine-rails 2.9.0

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

@@ -0,0 +1,464 @@
+module Refine::Conditions
+  class DateCondition < Condition
+    include ActiveModel::Validations
+    include HasClauses
+
+    validate :date1_must_be_real, :date2_must_be_real, :date1_must_be_less_than_date2
+
+    cattr_accessor :default_user_timezone, default: "UTC", instance_accessor: false
+    cattr_accessor :default_database_timezone, default: "UTC", instance_accessor: false
+    attr_reader :date1, :date2, :days, :show_human_readable_timezone
+
+    CLAUSE_EQUALS = Clauses::EQUALS
+    CLAUSE_DOESNT_EQUAL = Clauses::DOESNT_EQUAL
+
+    CLAUSE_LESS_THAN = Clauses::LESS_THAN
+    CLAUSE_LESS_THAN_OR_EQUAL = Clauses::LESS_THAN_OR_EQUAL
+
+    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_EXACTLY = Clauses::EXACTLY
+    CLAUSE_SET = Clauses::SET
+    CLAUSE_NOT_SET = Clauses::NOT_SET
+
+    ATTRIBUTE_TYPE_DATE = 0
+    ATTRIBUTE_TYPE_DATE_WITH_TIME = 1
+    ATTRIBUTE_TYPE_UNIX_TIMESTAMP = 2
+
+    I18N_PREFIX = "refine.refine_blueprints.date_condition."
+
+    def date1_must_be_real
+      return true unless date1
+      begin
+        Date.strptime(date1, "%Y-%m-%d")
+      rescue ArgumentError
+        errors.add(:base, I18n.t("#{I18N_PREFIX}date1_error"))
+        false
+      end
+    end
+
+    def date2_must_be_real
+      return true unless date2
+      begin
+        Date.strptime(date2, "%Y-%m-%d")
+      rescue ArgumentError
+        errors.add(:base, I18n.t("#{I18N_PREFIX}date2_error"))
+        false
+      end
+    end
+
+    def date1_must_be_less_than_date2
+      return true unless date1 && date2
+      if Date.strptime(date1, "%Y-%m-%d") > Date.strptime(date2, "%Y-%m-%d")
+        errors.add(:base, I18n.t("#{I18N_PREFIX}date1_greater_date2_error"))
+        false
+      else
+        true
+      end
+    end
+
+    def boot
+      @attribute_type = @attribute_type ||= ATTRIBUTE_TYPE_DATE
+      add_ensurance(ensure_timezone)
+    end
+
+    def set_input_parameters(input)
+      @date1 = input[:date1]
+      @date2 = input[:date2]
+      @days = input[:days]
+    end
+
+    def ensure_timezone
+      proc do
+        timezone_exists(database_timezone)
+        timezone_exists(user_timezone)
+      end
+    end
+
+    def timezone_exists(zone)
+      return if ActiveSupport::TimeZone[zone].present?
+      errors.add(:base, I18n.t("#{I18N_PREFIX}timezone_error", zone: zone))
+    end
+
+    def component
+      "date-condition"
+    end
+
+    # Returns the string representation of the timezone localized if you don't already have a Time object to work with
+    # NOTE: It is possible for a timezone to not have an acceptable abbreviation. In those cases the Time library outputs unhelpful shortened offsets.
+    # EG: "International Date Line West" outputs "-12"
+    # So parse the string to see if it's one of these shortened forms and if it is, restructure to a fully formed GMT offset EG "GMT-12:00"
+    def timezone_abbr
+      if @show_human_readable_timezone
+        tz_string = " (#{I18n.l(Time.now.in_time_zone(user_timezone), format: :z)})"
+        match = tz_string =~ /^ \([-+]?\d+\)$/
+        if !((tz_string =~ /^ \([-+]?\d+\)$/).nil?)
+          tz_string = get_standard_tz_offset(tz_string)
+        end
+        tz_string
+      else
+        ""
+      end
+    end
+
+    # We should probably consider using tzinfo or some other library for this in the future
+    def get_standard_tz_offset(offset_string)
+      stripped = offset_string.strip
+      matches = stripped.match /^\s*\(([+-]?)(\d{1,4})\)\s*$/
+      unless matches.length > 1
+        return offset_string
+      end
+
+      sign = matches[1]
+      digits = matches[2].ljust(4, '0') 
+      gmt_offset = " (GMT#{sign}#{digits[0..1]}:#{digits[2..3]})"
+
+      gmt_offset
+    end
+
+    def human_readable(input)
+      current_clause = get_clause_by_id(input[:clause])
+
+      case input[:clause]
+      when *[CLAUSE_EQUALS, CLAUSE_DOESNT_EQUAL, CLAUSE_LESS_THAN_OR_EQUAL, CLAUSE_GREATER_THAN_OR_EQUAL]
+        formatted_date1 = I18n.l(input[:date1].to_date, format: :dmy)
+        "#{display} #{current_clause.display} #{formatted_date1}#{timezone_abbr}"
+      when *[CLAUSE_BETWEEN, CLAUSE_NOT_BETWEEN]
+        formatted_date1 = I18n.l(input[:date1].to_date, format: :dmy)
+        formatted_date2 = I18n.l(input[:date2].to_date, format: :dmy)
+        and_i18n = I18n.t("#{I18N_PREFIX}and")
+
+        if formatted_date1 == formatted_date2
+          "#{display} #{get_clause_by_id(CLAUSE_EQUALS).display} #{formatted_date1}#{timezone_abbr}"
+        else
+          "#{display} #{current_clause.display} #{formatted_date1} #{and_i18n} #{formatted_date2}#{timezone_abbr}"
+        end
+      when *[CLAUSE_GREATER_THAN, CLAUSE_LESS_THAN, CLAUSE_EXACTLY]
+        days_i18n = I18n.t("#{I18N_PREFIX}days")
+        ago_i18n = I18n.t("#{I18N_PREFIX}ago")
+        from_now_i18n = I18n.t("#{I18N_PREFIX}from_now")
+        "#{display} #{current_clause.display} #{input[:days]} #{days_i18n} #{input[:modifier] == 'ago' ? ago_i18n : from_now_i18n}#{timezone_abbr}"
+      when *[CLAUSE_SET, CLAUSE_NOT_SET]
+        "#{display} #{current_clause.display}"
+      else
+        not_supported_i18n = I18n.t("#{I18N_PREFIX}not_supported")
+        raise "#{input[:clause]} #{not_supported_i18n}"
+      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_LESS_THAN_OR_EQUAL, CLAUSE_GREATER_THAN_OR_EQUAL]
+        formatted_date1 = I18n.l(input[:date1].to_date, format: :dmy)
+        "#{formatted_date1}#{timezone_abbr}"
+      when *[CLAUSE_BETWEEN, CLAUSE_NOT_BETWEEN]
+        formatted_date1 = I18n.l(input[:date1].to_date, format: :dmy)
+        formatted_date2 = I18n.l(input[:date2].to_date, format: :dmy)
+        and_i18n = I18n.t("#{I18N_PREFIX}and")
+        
+        if formatted_date1 == formatted_date2
+          "#{formatted_date1}#{timezone_abbr}"
+        else
+          "#{formatted_date1} #{and_i18n} #{formatted_date2}#{timezone_abbr}"
+        end
+      when *[CLAUSE_GREATER_THAN, CLAUSE_LESS_THAN, CLAUSE_EXACTLY]
+        days_i18n = I18n.t("#{I18N_PREFIX}and")
+        ago_i18n = I18n.t("#{I18N_PREFIX}days")
+        from_now_i18n = I18n.t("#{I18N_PREFIX}ago")
+        "#{input[:days]} #{days_i18n} #{input[:modifier] == 'ago' ? ago_i18n : from_now_i18n}#{timezone_abbr}"
+      when *[CLAUSE_SET, CLAUSE_NOT_SET]
+        ""
+      else
+        not_supported_i18n = I18n.t("#{I18N_PREFIX}not_supported")
+        raise "#{input[:clause]} #{not_supported_i18n}"
+      end
+    end
+
+    def attribute_is_date
+      attribute_is(ATTRIBUTE_TYPE_DATE)
+      self
+    end
+
+    def attribute_is_date_with_time
+      attribute_is(ATTRIBUTE_TYPE_DATE_WITH_TIME)
+      self
+    end
+
+    def attribute_is_unix_timestamp # time
+      attribute_is(ATTRIBUTE_TYPE_UNIX_TIMESTAMP)
+    end
+
+    def attribute_is(type)
+      @attribute_type = type
+      self
+    end
+
+    def with_human_readable_timezone(show)
+      @show_human_readable_timezone = show
+      self
+    end
+
+    def with_database_timezone(timezone)
+      @database_timezone = timezone
+      self
+    end
+
+    def with_user_timezone(timezone)
+      @user_timezone = timezone
+      self
+    end
+
+    def get_timezone(zone)
+      call_proc_if_callable(zone)
+    end
+
+    def user_timezone
+      get_timezone(@user_timezone ||= @@default_user_timezone)
+    end
+
+    def database_timezone
+      get_timezone(@database_timezone ||= @@default_database_timezone)
+    end
+
+    def clauses
+      [
+        Clause.new(CLAUSE_EQUALS, I18n.t("#{I18N_PREFIX}is_on"))
+          .requires_inputs("date1"),
+
+        Clause.new(CLAUSE_DOESNT_EQUAL, I18n.t("#{I18N_PREFIX}not_on"))
+          .requires_inputs("date1"),
+
+        Clause.new(CLAUSE_LESS_THAN_OR_EQUAL, I18n.t("#{I18N_PREFIX}is_on_or_before"))
+          .requires_inputs("date1"),
+
+        Clause.new(CLAUSE_GREATER_THAN_OR_EQUAL, I18n.t("#{I18N_PREFIX}is_on_or_after"))
+          .requires_inputs("date1"),
+
+        Clause.new(CLAUSE_BETWEEN, I18n.t("#{I18N_PREFIX}is_between"))
+          .requires_inputs(["date1", "date2"]),
+
+        Clause.new(CLAUSE_NOT_BETWEEN, I18n.t("#{I18N_PREFIX}is_not_between"))
+          .requires_inputs(["date1", "date2"]),
+
+        Clause.new(CLAUSE_GREATER_THAN, I18n.t("#{I18N_PREFIX}is_more_than"))
+          .requires_inputs(["days", "modifier"]),
+
+        Clause.new(CLAUSE_EXACTLY, I18n.t("#{I18N_PREFIX}is"))
+          .requires_inputs(["days", "modifier"]),
+
+        Clause.new(CLAUSE_LESS_THAN, I18n.t("#{I18N_PREFIX}is_less_than"))
+          .requires_inputs(["days", "modifier"]),
+
+        Clause.new(CLAUSE_SET, I18n.t("#{I18N_PREFIX}is_set")),
+
+        Clause.new(CLAUSE_NOT_SET, I18n.t("#{I18N_PREFIX}is_not_set")),
+      ]
+    end
+
+    def relative_clauses
+      [CLAUSE_GREATER_THAN, CLAUSE_LESS_THAN, CLAUSE_EXACTLY]
+    end
+
+    def is_relative_clause?
+      relative_clauses.include? clause
+    end
+
+    def modify_date_and_clause!(input)
+      @date1 = comparison_date(input)
+      @clause = standardize_clause(input)
+    end
+
+    def apply_condition(input, table, _inverse_clause)
+      if clause == CLAUSE_SET
+        return apply_clause_set(table)
+      end
+
+      if clause == CLAUSE_NOT_SET
+        return apply_clause_not_set(table)
+      end
+
+      modify_date_and_clause!(input) if is_relative_clause?
+
+      # TODO: Allow for custom clauses
+      if @attribute_type == ATTRIBUTE_TYPE_DATE
+        apply_standardized_values(table)
+      else
+        apply_standardized_values_with_time(table)
+      end
+    end
+
+    def comparison_date(input)
+      modified_days = days.to_i
+      modifier = input[:modifier]
+
+      # If the user has requested a certain number of days 'ago',then value
+      # needs to be negative
+
+      if modifier == "ago"
+        modified_days *= - 1
+      end
+      (Date.current + modified_days).strftime("%Y-%m-%d")
+    end
+
+    def standardize_clause(input)
+      modifier = input[:modifier]
+      case clause
+      when CLAUSE_GREATER_THAN
+        modifier == "ago" ? CLAUSE_LESS_THAN : CLAUSE_GREATER_THAN
+      when CLAUSE_LESS_THAN
+        modifier == "ago" ? CLAUSE_GREATER_THAN : CLAUSE_LESS_THAN
+      when CLAUSE_EXACTLY
+        CLAUSE_EQUALS
+      end
+    end
+
+    def start_of_day(day)
+      # Returns the start of day in the user timezone
+      # Day shifted to user time zone 00 based
+      day_in_user_tz = day.in_time_zone(user_timezone).beginning_of_day
+
+      # Get day_in_user_tz in database time zone
+      database_local = day_in_user_tz.in_time_zone(database_timezone)
+
+      offset = database_local.utc_offset
+      # Arel will convert to UTC before seaching, so add offset to account for db timezone
+      utc_start = database_local.in_time_zone("UTC")
+      utc_start + offset
+    end
+
+    def end_of_day(day)
+      day_in_user_tz = day.in_time_zone(user_timezone)
+      end_of_day = day_in_user_tz.end_of_day
+      database_local = end_of_day.in_time_zone(database_timezone)
+      offset = database_local.utc_offset
+      utc_end = database_local.in_time_zone("UTC")
+      utc_end + offset
+    end
+
+    def comparison_time(day)
+      # If comparison request, compare to the time the request is made (such as 3 days ago)
+      current_time = Time.current.in_time_zone(user_timezone)
+
+      # Day will be 00 based
+      day_in_user_tz = day.to_time(:utc).in_time_zone(user_timezone)
+
+      options = {hour: current_time.hour, min: current_time.min, sec: current_time.sec}
+
+      # The queried day shifted to local time hour::min::sec
+      day_time_shifted = day_in_user_tz.change(options)
+
+      database_local = day_time_shifted.in_time_zone(database_timezone)
+      offset = database_local.utc_offset
+      utc_comparison_time = database_local.in_time_zone("UTC")
+      utc_comparison_time + offset
+    end
+
+    def apply_standardized_values_with_time(table)
+      case clause
+      # At this point, `between` and `equal` are functionally the
+      # same, i.e. they are querying between two _times_.
+      when CLAUSE_EQUALS
+        apply_clause_between(table, start_of_day(date1), end_of_day(date1))
+      when CLAUSE_BETWEEN
+        apply_clause_between(table, start_of_day(date1), end_of_day(date2))
+
+      when CLAUSE_DOESNT_EQUAL
+        apply_clause_not_between(table, start_of_day(date1), end_of_day(date1))
+      when CLAUSE_NOT_BETWEEN
+        apply_clause_not_between(table, start_of_day(date1), end_of_day(date2))
+
+
+      when CLAUSE_LESS_THAN
+        apply_clause_less_than(comparison_time(date1), table)
+      when CLAUSE_GREATER_THAN
+        apply_clause_greater_than(comparison_time(date1), table)
+      when CLAUSE_GREATER_THAN_OR_EQUAL
+        if Refine::Rails.configuration.date_gte_uses_bod
+          datetime = start_of_day(date1)
+        else
+          datetime = comparison_time(date1)
+        end
+        apply_clause_greater_than_or_equal(datetime, table)
+      when CLAUSE_LESS_THAN_OR_EQUAL
+        if Refine::Rails.configuration.date_lte_uses_eod
+          datetime = end_of_day(date1)
+        else
+          datetime = comparison_time(date1)
+        end
+        apply_clause_less_than_or_equal(datetime, table)
+      end
+
+    end
+
+    def apply_standardized_values(table)
+      case clause
+      when CLAUSE_EQUALS
+        apply_clause_equals(date1, table)
+
+      when CLAUSE_DOESNT_EQUAL
+        apply_clause_doesnt_equal(date1, table)
+
+      when CLAUSE_LESS_THAN
+        apply_clause_less_than(date1, table)
+
+      when CLAUSE_GREATER_THAN
+        apply_clause_greater_than(date1, table)
+
+      when CLAUSE_GREATER_THAN_OR_EQUAL
+        apply_clause_greater_than_or_equal(date1, table)
+
+      when CLAUSE_LESS_THAN_OR_EQUAL
+        apply_clause_less_than_or_equal(date1, table)
+
+      when CLAUSE_BETWEEN
+        apply_clause_between(table, date1, date2)
+      end
+    end
+
+    def apply_clause_between(table, first_date, second_date)
+      table.grouping(table[:"#{attribute}"].between(first_date..second_date))
+    end
+
+    def apply_clause_not_between(table, first_date, second_date)
+      table.grouping(table[:"#{attribute}"].not_between(first_date..second_date))
+    end
+
+    def apply_clause_equals(value, table)
+      table.grouping(table[:"#{attribute}"].eq(value))
+    end
+
+    def apply_clause_doesnt_equal(value, table)
+      table.grouping(table[:"#{attribute}"].not_eq(value).or(table[:"#{attribute}"].eq(nil)))
+    end
+
+    def apply_clause_greater_than(value, table)
+      table.grouping(table[:"#{attribute}"].gt(value))
+    end
+
+    def apply_clause_greater_than_or_equal(value, table)
+      table.grouping(table[:"#{attribute}"].gteq(value))
+    end
+
+    def apply_clause_less_than(value, table)
+      table.grouping(table[:"#{attribute}"].lt(value))
+    end
+
+    def apply_clause_less_than_or_equal(value, table)
+      table.grouping(table[:"#{attribute}"].lteq(value))
+    end
+
+    def apply_clause_set(table)
+      table.grouping(table[:"#{attribute}"].not_eq(nil))
+    end
+
+    def apply_clause_not_set(table)
+      table.grouping(table[:"#{attribute}"].eq(nil))
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Refine::Conditions
+  class DateWithTimeCondition < DateCondition
+    def boot
+      @attribute_type = ATTRIBUTE_TYPE_DATE_WITH_TIME
+      super
+    end
+  end
+end

data/app/models/refine/conditions/errors/condition_clause_error.rb

@@ -0,0 +1,7 @@
+class Refine::Conditions::Errors::ConditionClauseError < StandardError
+  attr_reader :errors
+  def initialize(message, errors: [])
+    @errors = errors
+    super(message)
+  end
+end

data/app/models/refine/conditions/errors/criteria_limit_exceeded_error.rb

@@ -0,0 +1,2 @@
+class Refine::Conditions::Errors::CriteriaLimitExceededError < RuntimeError
+end

data/app/models/refine/conditions/errors/option_error.rb

@@ -0,0 +1,2 @@
+class Refine::Conditions::Errors::OptionError < RuntimeError
+end

data/app/models/refine/conditions/errors/relationship_error.rb

@@ -0,0 +1 @@
+class Refine::Conditions::Errors::RelationshipError < StandardError; end

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

@@ -0,0 +1,93 @@
+module Refine::Conditions
+  class FilterCondition < Condition
+    include HasClauses
+    include UsesAttributes
+    include ActiveModel::Validations
+
+    attr_reader :options
+
+    CLAUSE_IN = Clauses::IN
+    CLAUSE_NOT_IN = Clauses::NOT_IN
+
+    I18N_PREFIX = "refine.refine_blueprints.filter_condition."
+
+    def component
+      "filter-condition"
+    end
+
+    def boot
+      @options = nil
+      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 ensure_options
+      proc do
+        developer_options = get_options.call
+        # Options must evaluate to an array
+        if !developer_options.is_a? Array
+          raise I18n.t("#{I18N_PREFIX}options_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
+
+    # TODO improve this developer interface...
+    def with_scope(scope)
+      @options = []
+      scope.all.each do |filter|
+        @options << {id: filter.id, display: filter.name}
+      end
+      self
+    end
+
+    def stored_only
+      self
+    end
+
+    def get_options
+      proc do
+        @options = call_proc_if_callable(options)
+      end
+    end
+
+    def apply_condition(input, table, _inverse_clause)
+      filter_id = input[:selected].first.to_i
+      filter = Refine::Rails.configuration.stabilizer_classes[:db].new.from_stable_id(id: filter_id)
+      # TODO handle this more elegantly
+      raise I18n.t("#{I18N_PREFIX}not_found") if filter.blank?
+      # TODO - Filter initial query is currently handled on the filter class. ProductFilter.where....
+      # Is this the right way to handle it?
+      filter.make_sub_query(filter.blueprint)
+    end
+
+    def clauses
+      [
+        Clause.new(CLAUSE_IN, I18n.t("#{I18N_PREFIX}in")),
+        Clause.new(CLAUSE_NOT_IN, I18n.t("#{I18N_PREFIX}not_in"))
+      ]
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+module Refine::Conditions
+  module HasClauses
+
+    def self.included(klass)
+      klass.class_eval do
+        mattr_accessor :default_clause_display_map, default: {}, instance_accessor: false
+      end
+    end
+
+    def boot_has_clauses
+      @show_clauses = {}
+      add_rules({ clause: "required" })
+      with_meta({ clauses: get_clauses })
+      add_ensurance(ensure_clauses)
+      before_validate(before_clause_validation)
+    end
+
+    def clause_display_map
+      @clause_display_map ||= {}
+    end
+
+    def before_clause_validation(input = [])
+      proc do |input|
+        if input.present?
+          current_clause = clauses.select{ |clause| clause.id == input[:clause] }
+          if current_clause.present?
+            add_rules(current_clause[0].rules)
+          end
+        end
+      end
+    end
+
+    def custom_clauses
+      []
+    end
+
+    def remap_clause_displays(map)
+      clause_display_map.merge!(map)
+      self
+    end
+
+    def only_clauses(specific_clauses)
+      # Remove all clauses
+      clauses.map(&:id).each {|clause_id| update_show_clauses(clause_id, false) }
+      # Add specific clauses by id, not by fully qualified clause
+      specific_clauses.each {|clause| update_show_clauses(clause, true) }
+      self
+    end
+
+    def with_clauses(clauses_to_include)
+      clauses_to_include.each {|clause| update_show_clauses(clause, true) }
+      self
+    end
+
+    def without_clauses(clauses_to_exclude)
+      clauses_to_exclude.each {|clause| update_show_clauses(clause, false) }
+      self
+    end
+
+    def update_show_clauses(clause, value)
+      @show_clauses.merge!({"#{clause}": value})
+    end
+
+    def ensure_clauses
+      proc do
+        clauses = get_clauses.call
+        if clauses.any?
+          clauses.each { |clause| ensure_clause(clause) }
+        else
+          errors.add(:base, I18n.t("refine.refine_blueprints.has_clauses.not_determined"))
+          raise Errors::ConditionClauseError, "#{errors.full_messages}"
+        end
+      end
+    end
+
+    def ensure_clause(clause)
+      if !clause.is_a? Clause
+        errors.add(:base, I18n.t("refine.refine_blueprints.has_clauses.must_be_instance_of", instance: "#{Clause::class}"))
+        raise Errors::ConditionClauseError, "#{errors.full_messages}"
+      end
+      if clause.id.blank? || clause.display.blank?
+        errors.add(:base, I18n.t("refine.refine_blueprints.has_clauses.must_have_id_and_display"))
+        raise Errors::ConditionClauseError, "#{errors.full_messages}"
+      end
+    end
+
+    def get_clause_by_id(id)
+      clause = get_clauses.call().find{ |clause| clause.id == id }
+      raise I18n.t("refine.refine_blueprints.has_clauses.not_found", id: id) unless clause
+      clause
+    end
+
+    def get_clauses
+      proc do
+        returned_clauses = clauses.dup
+        # Clause display map takes precedence over default display map. Merge order matters.
+        map = self.class.default_clause_display_map.merge(clause_display_map)
+        @show_clauses.each do |clause_id, rule|
+          filterable_clause_index = returned_clauses.index{ |clause| clause.id.to_sym == clause_id }
+          if rule == false
+            returned_clauses.delete_at(filterable_clause_index)
+          elsif rule == true
+            add_clause = returned_clauses.find{|clause| clause.id.to_sym == clause_id }
+            returned_clauses << add_clause if !add_clause
+          end
+        end
+        # Rewrite display if the key exists in the map.
+        returned_clauses.each do |clause|
+          if map.key?(clause.id.to_sym)
+            clause.display = map[clause.id.to_sym]
+          end
+        end
+        returned_clauses
+      end
+    end
+  end
+end