create_custom_attributes 0.5.0

data/lib/custom_attributes/field_types/list_field_type.rb

@@ -0,0 +1,36 @@
+module CustomAttributes
+  class ListFieldType < List
+    include Singleton
+
+    def possible_custom_value_options(custom_value)
+      options = possible_values_options(custom_value.custom_field)
+      missing = [custom_value.value].flatten.reject(&:blank?) - options
+      if missing.any?
+        options += missing
+      end
+      options
+    end
+
+    def possible_values_options(custom_field, object=nil)
+      custom_field.possible_values
+    end
+
+    def validate_custom_field(custom_field)
+      errors = []
+      errors << [:possible_values, :blank] if custom_field.possible_values.blank?
+      errors << [:possible_values, :invalid] unless custom_field.possible_values.is_a? Array
+      errors
+    end
+
+    def validate_custom_value(custom_value)
+      values = Array.wrap(custom_value.value).reject {|value| value.to_s == ''}
+      invalid_values = values - Array.wrap(custom_value.value_was) - custom_value.custom_field.possible_values
+      if invalid_values.any?
+        [::I18n.t('activerecord.errors.messages.inclusion')]
+      else
+        []
+      end
+    end
+
+  end
+end

data/lib/custom_attributes/field_types/numeric.rb

@@ -0,0 +1,5 @@
+module CustomAttributes
+  class Numeric < Unbounded
+
+  end
+end

data/lib/custom_attributes/field_types/string_field_type.rb

@@ -0,0 +1,5 @@
+module CustomAttributes
+  class StringFieldType < Unbounded
+    include Singleton
+  end
+end

data/lib/custom_attributes/field_types/text_field_type.rb

@@ -0,0 +1,10 @@
+module CustomAttributes
+  class TextFieldType < Unbounded
+    include Singleton
+
+    def edit_tag(view, tag_id, tag_name, custom_value, options={})
+      view.text_area_tag(tag_name, custom_value.value, options.merge(:id => tag_id, :rows => 8))
+    end
+
+  end
+end

data/lib/custom_attributes/field_types/unbounded.rb

@@ -0,0 +1,16 @@
+module CustomAttributes
+  # This class is only to be extended by types that need length validation
+  class Unbounded < FieldType
+    def validate_single_value(custom_field, value, customizable = nil)
+      errs = super
+      value = value.to_s
+      if custom_field.min_length && value.length < custom_field.min_length
+        errs << ::I18n.t('activerecord.errors.messages.too_short', count: custom_field.min_length)
+      end
+      if custom_field.max_length && custom_field.max_length > 0 && value.length > custom_field.max_length
+        errs << ::I18n.t('activerecord.errors.messages.too_long', count: custom_field.max_length)
+      end
+      errs
+    end
+  end
+end

data/lib/custom_attributes/fluent_search_query.rb

@@ -0,0 +1,168 @@
+require 'custom_attributes/search_query'
+
+module CustomAttributes
+  class FluentSearchQuery
+    def initialize(customizable)
+      @search_query = CustomAttributes::SearchQuery.new
+      @search_query.customizable = customizable unless customizable.nil?
+
+      @raw_results = nil
+      @field_list = {}
+      @field_queries = {}
+      @field_config = {}
+    end
+
+    def query(query)
+      @search_query.query = query
+
+      self
+    end
+
+    def field_list(field_list)
+      @field_list = Hash[field_list.map do |type, fields|
+        fields = fields.split(',') if fields.is_a? String
+        [type, fields]
+      end]
+
+      self
+    end
+
+    def field_queries(field_queries)
+      @field_queries = field_queries
+
+      self
+    end
+
+    def field_config(field_config)
+      @field_config = field_config
+
+      self
+    end
+
+    def filter_by(field_list)
+      @search_query.filter_by.merge! field_list
+
+      self
+    end
+
+    def sort_by(field_list)
+      @search_query.sort_by.merge! field_list
+
+      self
+    end
+
+    def match_any
+      @search_query.match_any = true
+
+      self
+    end
+
+    def page(page)
+      @search_query.page = page.to_i
+
+      self
+    end
+
+    def per_page(per_page)
+      @search_query.per_page = per_page.to_i
+
+      self
+    end
+
+    # Performs the search
+    def search
+      @raw_results = @search_query.customizable.class.__elasticsearch__.search(query_hash)
+
+      self
+    end
+
+    # Returns the results after search has been performed
+    # Call search() first!
+    def results
+      return nil if @raw_results.nil?
+
+      begin
+        @raw_results.count
+
+        @raw_results.results
+      rescue Faraday::ConnectionFailed => e
+        @search_query.customizable.class.handle_search_connection_error(e)
+      end
+    end
+
+    # Fetches the ActiveRecord database records
+    # Does not perform search, so call search() first!
+    def records
+      return nil if @raw_results.nil?
+
+      begin
+        @raw_results.count
+
+        @raw_results.records
+      rescue Faraday::ConnectionFailed => e
+        @search_query.customizable.class.handle_search_connection_error(e)
+      end
+    end
+
+    # Performs the search and returns the count of results
+    def count
+      search.results.count
+    rescue Faraday::ConnectionFailed => e
+      @search_query.customizable.class.handle_search_connection_error(e)
+    end
+
+    # Use at own risk, no Connection Exception handling here
+    def raw
+      @raw_results
+    end
+
+    # Return the hash that is conform to elasticsearch's DSL
+    # Does not perform a search query!
+    def query_hash
+      process_field_list
+
+      @search_query.build
+    end
+
+    private
+
+    # Combine field list, field queries and field config into one field list
+    def process_field_list
+      # apply default fields if no user specified fields are present
+      if @field_list.empty?
+        field_list = @search_query.default_fields
+      else
+        field_list = Hash[@field_list.map { |type, list| [type, Hash[list.map { |v| [v.to_sym, {}] }]] }]
+      end
+
+      # field list is in the format {fields: {field1: {}, field2: {},...}, custom_fields: {field1: {}, ...}}
+      # this mapper has the purpose to populate the hash with additional configuration on a per-field basis
+      #
+      # type: either :fields or :custom_fields
+      # list: a hash of fields with options
+      field_list.map do |type, list|
+        [
+          type,
+          Hash[list.map do |slug, options|
+            # apply options already present in the field_list (possible default settings)
+            field_options = options
+
+            # overwrite query (fulltext search) with field specific setting
+            if @field_queries[type] && @field_queries[type][slug]
+              field_options[:query] = @field_queries[type][slug]
+            end
+
+            # add other configuration such as fuzziness, operator, ...
+            if @field_config[type] && @field_config[type][slug]
+              field_options.merge! @field_config[type][slug]
+            end
+
+            [slug, field_options]
+          end]
+        ]
+      end
+
+      @search_query.field_list = field_list
+    end
+  end
+end

data/lib/custom_attributes/search_query.rb

@@ -0,0 +1,229 @@
+require 'custom_attributes/search_query_field'
+
+module CustomAttributes
+  # Builds a query in elastic search DSL
+  class SearchQuery
+    attr_accessor :customizable, :query, :field_list, :defaults, :sort_by, :page, :per_page, :match_any, :filter_by
+
+    def build
+      {
+        query: subquery,
+        from: from,
+        size: per_page,
+        sort: sort_hash_to_array
+      }
+    end
+
+    def from
+      (page - 1) * per_page
+    end
+
+    # fulltext search query, by default applied to all fields
+    def query
+      @query ||= '*'
+    end
+
+    def page
+      @page ||= 1
+    end
+
+    def per_page
+      @per_page ||= 20
+    end
+
+    def filter_by
+      @filter_by ||= {}
+    end
+
+    def sort_by
+      @sort_by ||= {}
+    end
+
+    def field_list
+      @field_list ||= {}
+    end
+
+    def defaults
+      {
+        query: query,
+        fuzziness: 0
+      }
+    end
+
+    def match_any?
+      @match_any
+    end
+
+    def default_fields
+      default_fields = {
+        custom_fields: Hash[customizable.available_custom_fields
+                                         .select { |cf| cf.searchable == true }
+                                         .map { |cf| [cf.slug.to_sym, {}] }]
+      }
+
+      if customizable.present?
+        default_fields[:fields] = Hash[
+          customizable.class.default_fields.map { |f| [f.to_sym, {}] }
+        ]
+      end
+
+      default_fields
+    end
+
+    private
+
+    def subquery
+      filter = filter_hash_to_term_array + [{ term: { visible_in_search: true } }]
+
+      # match all documents if no particular query isset
+      if query == '*' && field_list.empty?
+        return {
+          bool: {
+            must: [
+              {
+                match_all: {}
+              }
+            ],
+            filter: filter
+          }
+        }
+      end
+
+      {
+        bool: {
+          filter: filter
+        }.merge(match_any_decorator(collect_queries))
+      }
+    end
+
+    def collect_queries
+      # build field specific queries
+      queries = model_field_queries + custom_value_queries
+
+      # if there are not field specific queries, match all fields
+      if queries.count.zero?
+        if query == '*'
+          { match_all: {} }
+        else
+          { match: { _all: query } }
+        end
+      else
+        queries
+      end
+    end
+
+    def custom_value_queries
+      return [] if filter_only_custom_fields(field_list).count.zero?
+
+      filter_only_custom_fields(field_list).map do |field_slug, field|
+        custom_query_scaffold(field.to_query_hash, field_slug) unless field.to_query_hash.empty?
+      end.compact
+    end
+
+    def model_field_queries
+      return [] if filter_out_custom_fields(field_list).count.zero?
+
+      queries = filter_out_custom_fields(field_list).map do |field_slug, field|
+        { match: { field_slug => field.to_query_hash } } unless field.to_query_hash.empty?
+      end.compact
+
+      return [] if queries.empty?
+
+      [{
+        bool: {
+          should: queries,
+          minimum_should_match: 1
+        }
+      }]
+    end
+
+    def sort_hash_to_array
+      hash_to_array(sort_by) do |type, field_slug, field_data|
+        if type == :custom_fields
+          next unless find_custom_field_by_slug(field_slug).sortable
+          {
+            'custom_values.value.raw' => {
+              order: field_data || 'asc',
+              nested_path: 'custom_values',
+              nested_filter: {
+                term: { 'custom_values.custom_field_id' => resolve_custom_field_id(field_slug) }
+              }
+            }
+          }
+        else
+          { field_slug.to_s => { order: field_data } }
+        end
+      end
+    end
+
+    def filter_hash_to_term_array
+      hash_to_array(filter_by) do |type, field_slug, field_data|
+        if type == :custom_fields
+          custom_query_scaffold(field_data, field_slug, true)
+        else
+          key = 'term'
+          key = key.pluralize if field_data.is_a? Array
+
+          { key.to_sym => { field_slug.to_s => field_data } }
+        end
+      end
+    end
+
+    def filter_out_custom_fields(fields)
+      return {} if fields[:fields].nil?
+
+      Hash[fields[:fields].map { |k, v| [k, CustomAttributes::SearchQueryField.new(v, defaults)] }]
+    end
+
+    def filter_only_custom_fields(fields)
+      return {} if fields[:custom_fields].nil?
+
+      Hash[fields[:custom_fields].map { |k, v| [k, CustomAttributes::SearchQueryField.new(v, defaults)] }]
+    end
+
+    def resolve_custom_field_id(field_slug)
+      find_custom_field_by_slug(field_slug).try(:id) || raise('Field id not found')
+    end
+
+    def find_custom_field_by_slug(field_slug)
+      customizable.available_custom_fields.find { |cf| cf.slug == field_slug.to_s } || raise('Field not found')
+    end
+
+    def hash_to_array(field_list)
+      field_list.map do |type, fields|
+        fields.map do |field_slug, field_data|
+          yield(type, field_slug, field_data)
+        end
+      end.flatten.compact
+    end
+
+    def match_any_decorator(query_array)
+      if !match_any?
+        { must: query_array }
+      else
+        { should: query_array, minimum_should_match: 1 }
+      end
+    end
+
+    def custom_query_scaffold(query, field_slug, filter = false)
+      condition = { match: { 'custom_values.value' => query } }
+      condition = { term: { 'custom_values.value.raw' => query } } if filter
+
+      {
+        nested: {
+          path: 'custom_values',
+          query: {
+            bool: {
+              must: [
+                condition,
+                {
+                  term: { 'custom_values.custom_field_id' => resolve_custom_field_id(field_slug) }
+                }
+              ]
+            }
+          }
+        }
+      }
+    end
+  end
+end