card-mod-search 0.11.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1b91e3f82c4631b82c56aad295dc20b128f9fffcbf8d038e927b5b5bf4ebdc5c
+  data.tar.gz: 88b0423d13d1eba7d6a1e9e8f1f9b859d13b85491613ae05efe7970e15156d17
+SHA512:
+  metadata.gz: fbe34fa188b58c055449bd6789106ec32fa2652d80e8fa9ccb7147d0eab6d6a7a0905fbba84128f7c43185d9fe1609227ad07aefbdb59f8476e4d817c89f50a2
+  data.tar.gz: bab5d5d2e0af84aa1e5e0a35dd1aff04103dcaf186c10b2f8590f78ddb6a676cea3005a4e83a5c2c18bdcde8bf075721357fd49c9800895d88f3271801527a69

data/lib/card/filter_query.rb

@@ -0,0 +1,74 @@
+class Card
+  # Class for generating CQL based on filter params
+  class FilterQuery
+    def initialize filter_keys_with_values, extra_cql={}
+      @filter_cql = Hash.new { |h, k| h[k] = [] }
+      @rules = yield if block_given?
+      @rules ||= {}
+      @filter_keys_with_values = filter_keys_with_values
+      @extra_cql = extra_cql
+      prepare_filter_cql
+    end
+
+    def add_to_cql key, value
+      @filter_cql[key] << value
+    end
+
+    def add_rule key, value
+      return unless value.present?
+      case @rules[key]
+      when Symbol
+        send("#{@rules[key]}_rule", key, value)
+      when Proc
+        @rules[key].call(key, value).each do |cql_key, val|
+          @filter_cql[cql_key] << val
+        end
+      else
+        send("#{key}_cql", value)
+      end
+    end
+
+    def to_cql
+      @cql = {}
+      @filter_cql.each do |cql_key, values|
+        next if values.empty?
+        case cql_key
+        when :right_plus, :left_plus, :type
+          merge_using_and cql_key, values
+        else
+          merge_using_array cql_key, values
+        end
+      end
+      @cql.merge @extra_cql
+    end
+
+    private
+
+    def prepare_filter_cql
+      @filter_keys_with_values.each do |key, values|
+        add_rule key, values
+      end
+    end
+
+    def merge_using_array cql_key, values
+      @cql[cql_key] = values.one? ? values.first : values
+    end
+
+    def merge_using_and cql_key, values
+      hash = build_nested_hash cql_key, values
+      @cql.deep_merge! hash
+    end
+
+    # nest values with the same key using :and
+    def build_nested_hash key, values
+      return { key => values[0] } if values.one?
+      val = values.pop
+      { key => val, and: build_nested_hash(key, values) }
+    end
+
+    def name_cql name
+      return unless name.present?
+      @filter_cql[:name] = ["match", name]
+    end
+  end
+end

data/set/abstract/00_filter_helper.rb

@@ -0,0 +1,46 @@
+format do
+  def filter_param field
+    filter_hash[field.to_sym]
+  end
+
+  def filter_hash
+    @filter_hash ||= filter_hash_from_params || default_filter_hash
+  end
+
+  def filter_hash_from_params
+    return unless Env.params[:filter].present?
+
+    Env.hash(Env.params[:filter]).deep_symbolize_keys
+  end
+
+  def sort_param
+    @sort_param ||= safe_sql_param :sort
+  end
+
+  def safe_sql_param key
+    param = Env.params[key]
+    param.blank? ? nil : Card::Query.safe_sql(param)
+  end
+
+  def filter_keys_with_values
+    filter_keys.map do |key|
+      values = filter_param(key)
+      values.present? ? [key, values] : next
+    end.compact
+  end
+
+  # initial values for filtered search
+  def default_filter_hash
+    {}
+  end
+
+  def extra_paging_path_args
+    super.merge filter_and_sort_hash
+  end
+
+  def filter_and_sort_hash
+    { filter: filter_hash }.tap do |hash|
+      hash[:sort] = sort_param if sort_param
+    end
+  end
+end

data/set/abstract/02_search_params.rb

@@ -0,0 +1,52 @@
+format do
+  def search_params
+    @search_params ||= default_search_params
+  end
+
+  # used for override
+  def default_search_params
+    if (qparams = query_params)
+      paging_params.merge vars: qparams
+    else
+      paging_params
+    end
+  end
+
+  def paging_params
+    { limit: limit, offset: offset }
+  end
+
+  def query_params
+    return nil unless (vars = params[:query])
+
+    Env.hash vars
+  end
+
+  def default_limit
+    100
+  end
+
+  def extra_paging_path_args
+    return {} unless (vars = query_params)
+
+    { query: vars }
+  end
+end
+
+format :html do
+  def default_limit
+    Cardio.config.paging_limit || 20
+  end
+end
+
+format :json do
+  def default_limit
+    20
+  end
+end
+
+format :rss do
+  def default_limit
+    25
+  end
+end

data/set/abstract/03_filter.rb

@@ -0,0 +1,29 @@
+# include_set Abstract::Utility
+
+format do
+  def filter_class
+    Card::FilterQuery
+  end
+
+  def filter_keys
+    [:name]
+  end
+
+  def filter_keys_from_params
+    filter_hash.keys.map(&:to_sym) - [:not_ids]
+  end
+
+  def sort_options
+    { "Alphabetical": :name, "Recently Added": :create }
+  end
+end
+
+format :html do
+  view :filtered_content, template: :haml, wrap: :slot
+
+  view :filtered_results do
+    wrap { render_core }
+  end
+
+  view :selectable_filtered_content, template: :haml, cache: :never
+end

data/set/abstract/03_filter/_filter_input.haml

@@ -0,0 +1,8 @@
+._filter-input.filter-input-group.input-group.input-group-sm{"data-category": key, "class": "_filter-input-#{key}" }
+  .input-group-prepend.filter-input-prepend
+    %button.btn.btn-secondary.input-group-text.p-1._delete-filter-input{:type => "button"}
+      %small.text-muted
+        = fa_icon :times
+    %span.input-group-text._selected-category.text-muted
+      = category[:label]
+  = category[:input_field]

data/set/abstract/03_filter/filter_form.haml

@@ -0,0 +1,56 @@
+
+.card.w-100.nodblclick
+  .card-body
+    ._filter-widget
+      // FILTERING PROTOTYPES
+      ._filter-input-field-prototypes.d-none
+        - categories.each do |key, category|
+          = haml_partial :filter_input, key: key, category: category
+
+
+      // FORM
+      %form._filter-form{form_args, "accept-charset": "UTF-8",
+                                    "data-remote": "true",
+                                    method: "get"}
+        - not_ids = params.dig :filter, :not_ids
+        %input{ type: :hidden,
+                name: "filter[not_ids]",
+                class: "_not-ids",
+                value: not_ids }
+        = render_quick_filters
+        .filter-and-sort.d-flex.flex-wrap
+          - if sort_input_field.present?
+            // SORTING
+            .sort-in-filter-form
+              %i.fa.fa-sort.filter-section-icon
+              .input-group.input-group-sm.flex-nowrap.sort-input-group.mb-2.mr-2
+                .input-group-prepend
+                  %span.input-group-text.text-muted Sort
+                = sort_input_field
+
+          // FILTERING
+          .filter-in-filter-form
+            %i.fa.fa-filter.filter-section-icon
+            ._filter-container.d-flex.flew-row.flex-wrap
+              // FILTERS inserted here
+
+              // ADD FILTER DROPDOWN
+              .dropdown._add-filter-dropdown.mr-2
+                %button.btn.btn-sm.btn-primary.dropdown-toggle{"aria-expanded": "false",
+                                                               "aria-haspopup": "true",
+                                                               "data-toggle": "dropdown",
+                                                               type: "button" }
+                  More Filters
+                .dropdown-menu
+                  - categories.each do |key, category|
+                    %a{ class: "dropdown-item _filter-category-select",
+                        href: "#",
+                        "data-category": key,
+                        "data-label": category[:label],
+                        "data-active": ("true" if category[:active])}
+                      = category[:label]
+
+              // RESET BUTTON
+              ._reset-filter{ "data-reset": reset_filter_data }
+                %button.btn.btn-sm.btn-secondary{ type: "button" }
+                  %i.fa.fa-sync

data/set/abstract/03_filter/filter_form.rb

@@ -0,0 +1,101 @@
+format :html do
+  # sort and filter ui
+  view :filter_form, cache: :never do
+    filter_fields slot_selector: "._filter-result-slot",
+                  sort_field: _render(:sort_formgroup)
+  end
+
+  view :quick_filters, cache: :never do
+    return "" unless quick_filter_list.present?
+
+    haml :quick_filters, filter_list: normalized_quick_filter_list
+  end
+
+  def normalized_quick_filter_list
+    quick_filter_list.map do |hash|
+      quick_filter_item hash.clone, hash.keys.first
+    end
+  end
+
+  def reset_filter_data
+    JSON default_filter_hash
+  end
+
+  def quick_filter_item hash, filter_key
+    {
+      text: (hash.delete(:text) || hash[filter_key]),
+      class: css_classes(hash.delete(:class),
+                         "_filter-link quick-filter-by-#{filter_key}"),
+      filter: JSON(hash[:filter] || hash)
+    }
+  end
+
+  # for override
+  def quick_filter_list
+    []
+  end
+
+  # for override
+  def custom_quick_filters
+    ""
+  end
+
+  # @param data [Hash] the filter categories. The hash needs for every category
+  #   a hash with a label and a input_field entry.
+  def filter_form data={}, sort_input_field=nil, form_args={}
+    haml :filter_form, categories: data,
+                       sort_input_field: sort_input_field,
+                       form_args: form_args
+  end
+
+  def filter_fields slot_selector: nil, sort_field: nil
+    form_args = { action: filter_action_path, class: "slotter" }
+    form_args["data-slot-selector"] = slot_selector if slot_selector
+    filter_form filter_form_data, sort_field, form_args
+  end
+
+  def filter_form_data
+    all_filter_keys.each_with_object({}) do |cat, h|
+      h[cat] = { label: filter_label(cat),
+                 input_field: _render("filter_#{cat}_formgroup"),
+                 active: active_filter?(cat) }
+    end
+  end
+
+  def active_filter? field
+    if filter_keys_from_params.present?
+      filter_hash.key? field
+    else
+      default_filter? field
+    end
+  end
+
+  def default_filter? field
+    default_filter_hash.key? field
+  end
+
+  def filter_label field
+    # return "Keyword" if field.to_sym == :name
+    #
+    filter_label_from_method(field) || filter_label_from_name(field)
+  end
+
+  def filter_label_from_method field
+    try "#{field}_filter_label"
+  end
+
+  def filter_label_from_name field
+    Card.fetch_name(field) { field.to_s.titleize }
+  end
+
+  def filter_action_path
+    path
+  end
+
+  view :sort_formgroup, cache: :never do
+    select_tag "sort",
+               options_for_select(sort_options, current_sort),
+               class: "pointer-select _filter-sort form-control",
+               "data-minimum-results-for-search": "Infinity"
+  end
+end

data/set/abstract/03_filter/filtered_content.haml

@@ -0,0 +1,5 @@
+._filtered-content.nodblclick
+  .filter-form
+    = render_filter_form
+  .filtered-results
+    = render_filtered_results home_view: :filtered_results

data/set/abstract/03_filter/form_helper.rb

@@ -0,0 +1,105 @@
+include_set Abstract::FilterHelper
+
+format :html do
+  view :filter_name_formgroup, cache: :never do
+    text_filter :name
+  end
+
+  def select_filter field, default=nil, options=nil
+    options ||= filter_options field
+    options.unshift(["--", ""]) unless default
+    select_filter_tag field, default, options
+  end
+
+  def multiselect_filter field, default=nil, options=nil
+    options ||= filter_options field
+    multiselect_filter_tag field, default, options
+  end
+
+  def text_filter field, default=nil, opts={}
+    value = filter_param(field) || default
+    text_filter_with_name_and_value filter_name(field), value, opts
+  end
+
+  def text_filter_with_name_and_value name, value, opts
+    opts[:class] ||= "simple-text"
+    add_class opts, "form-control"
+    text_field_tag name, value, opts
+  end
+
+  def range_filter field, default={}, opts={}
+    add_class opts, "simple-text range-filter-subfield"
+    default ||= {}
+    output [range_sign(:from),
+            sub_text_filter(field, :from, default, opts),
+            range_sign(:to),
+            sub_text_filter(field, :to, default, opts)]
+  end
+
+  def range_sign side
+    dir = side == :from ? "right" : "left"
+    wrap_with :span, class: "input-group-prepend" do
+      fa_icon("chevron-circle-#{dir}", class: "input-group-text")
+    end
+  end
+
+  def sub_text_filter field, subfield, default={}, opts={}
+    name = "filter[#{field}][#{subfield}]"
+    value = filter_hash.dig(field, subfield) || default[subfield]
+    text_filter_with_name_and_value name, value, opts
+  end
+
+  def autocomplete_filter type_code, options_card=nil
+    options_card ||= Card::Name[type_code, :type, :by_name]
+    text_filter type_code, "", class: "#{type_code}_autocomplete",
+                               "data-options-card": options_card
+  end
+
+  def multiselect_filter_tag field, default, options, html_options={}
+    html_options[:multiple] = true
+    select_filter_tag field, default, options, html_options
+  end
+
+  def select_filter_tag field, default, options, html_options={}
+    name = filter_name field, html_options[:multiple]
+    options = options_for_select options, (filter_param(field) || default)
+    normalize_select_filter_tag_html_options field, html_options
+    select_tag name, options, html_options
+  end
+
+  # alters html_options hash
+  def normalize_select_filter_tag_html_options field, html_options
+    pointer_suffix = html_options[:multiple] ? "multiselect" : "select"
+    add_class html_options, "pointer-#{pointer_suffix} filter-input #{field} " \
+                            "_filter_input_field _no-select2 form-control"
+    # _no-select2 because select is initiated after filter is opened.
+    html_options[:id] = "filter-input-#{unique_id}"
+  end
+
+  def filter_name field, multi=false
+    "filter[#{field}]#{'[]' if multi}"
+  end
+
+  def filter_options field
+    raw = send("#{field}_options")
+    raw.is_a?(Array) ? raw : option_hash_to_array(raw)
+  end
+
+  def option_hash_to_array hash
+    hash.each_with_object([]) do |(key, value), array|
+      array << [key, value.to_s]
+      array
+    end
+  end
+
+  def type_options type_codename, order="asc", max_length=nil
+    Card.cache.fetch "#{type_codename}-TYPE-OPTIONS" do
+      res = Card.search type: type_codename, return: :name, sort: "name", dir: order
+      max_length ? (res.map { |i| [trim_option(i, max_length), i] }) : res
+    end
+  end
+
+  def trim_option option, max_length
+    option.size > max_length ? "#{option[0..max_length]}..." : option
+  end
+end