card-mod-search 0.11.0

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

@@ -0,0 +1,38 @@
+format do
+  # all filter keys in the order they were selected
+  def all_filter_keys
+    @all_filter_keys ||= filter_keys_from_params | filter_keys
+  end
+
+  def filter_and_sort_cql
+    filter_cql.merge sort_cql
+  end
+
+  def filter_cql
+    return {} if filter_hash.empty?
+
+    filter_cql_from_params
+  end
+
+  # separate method is needed for tests
+  def filter_cql_from_params
+    filter_class.new(filter_keys_with_values, blocked_id_cql).to_cql
+  end
+
+  def sort_cql
+    { sort: current_sort }
+  end
+
+  def blocked_id_cql
+    not_ids = filter_param :not_ids
+    not_ids.present? ? { id: ["not in", not_ids.split(",")] } : {}
+  end
+
+  def current_sort
+    sort_param || default_sort_option
+  end
+
+  def default_sort_option
+    card.cql_content[:sort]
+  end
+end

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

@@ -0,0 +1,11 @@
+.quick-filter._quick-filter
+  %i.fa.fa-bolt.filter-section-icon
+  .quick-filter-links.d-flex.flex-wrap
+    - filter_list.each do |f|
+      %a{ "data-filter": f[:filter],
+          href: "#",
+          class: f[:class],
+          title: "Quick Filter: #{f[:text]}" }
+        = f[:icon]
+        = f[:text]
+    = custom_quick_filters

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

@@ -0,0 +1,2 @@
+._selectable-filtered-content{ "data-input-selector" => Env.params["input_selector"] }
+  = render_filtered_content

data/set/abstract/04_right_filter_form.rb

@@ -0,0 +1,26 @@
+# To be included in a field card to get a filter for the parent.
+# The core view renders a filter for the left card.
+
+include_set Set::Abstract::Filter
+
+def virtual?
+  new?
+end
+
+format :html do
+  def filter_action_path
+    path mark: card.name.left, view: filter_view
+  end
+
+  view :core, cache: :never do
+    filter_fields slot_selector: filter_selector
+  end
+
+  def filter_view
+    :filter_result
+  end
+
+  def filter_selector
+    ".#{filter_view}-view"
+  end
+end

data/set/abstract/05_search.rb

@@ -0,0 +1,80 @@
+include_set Abstract::Paging
+include_set Abstract::SearchParams
+include_set Abstract::Filter
+
+def search _args={}
+  raise Error, "search not overridden"
+end
+
+def cached_search args={}
+  @search_results ||= {}
+  @search_results[args.to_s] ||= search args
+end
+
+def returning item, args
+  args[:return] = item
+  yield
+end
+
+def item_cards args={}
+  args[:limit] ||= 0
+  returning(:card, args) { search args }
+end
+
+def item_names args={}
+  args[:limit] ||= 0
+  returning(:name, args) { search args }
+end
+
+def item_ids args={}
+  args[:limit] ||= 0
+  returning(:id, args) { search args }
+end
+
+def count args={}
+  args[:offset] = 0
+  args[:limit] = 0
+  returning(:count, args) { search args }
+end
+
+# for override
+def item_type
+  nil
+end
+
+def each_item_name_with_options _content=nil
+  options = {}
+  item = fetch_query.statement[:view]
+  options[:view] = item if item
+  item_names.each do |name|
+    yield name, options
+  end
+end
+
+format do
+  def search_with_params
+    @search_with_params ||= search_with_rescue search_params
+  end
+
+  def count_with_params
+    @count_with_params ||= search_with_rescue search_params.merge(return: :count)
+  end
+
+  def search_with_rescue query_args
+    rescuing_bad_query query_args do
+      card.cached_search query_args
+    end
+  end
+
+  def rescuing_bad_query query_args
+    yield
+  rescue Error::BadQuery => e
+    Rails.logger.info "BadQuery: #{query_args}"
+    e
+  end
+
+  def implicit_item_view
+    view = voo_items_view || default_item_view
+    Card::View.normalize view
+  end
+end

data/set/abstract/05_search/checkbox_item.haml

@@ -0,0 +1,5 @@
+.checkbox-list-item.w-100.d-flex
+  .checkbox-side
+    = check_box_tag item_card.name, item_card.key, false, class: "_checkbox-list-checkbox"
+  .item-view-side{ style: "background: #fff" }
+    = nest_item item_card

data/set/abstract/05_search/select_item.haml

@@ -0,0 +1,15 @@
+.filter-header.card-header
+  %h5
+    Select Item
+    .badge.badge-secondary
+      = card.count
+.filter-selector.p-2
+  - if card.count > 0
+    .filter-bulk-selector.pb-3
+      %input#select-all._select-all{name: "", type: "checkbox", value: ""}
+      %label{for: "select-all"}
+        select
+        %span._unselected-items
+          = search_with_params.size
+        following
+  = render :checkbox_list

data/set/abstract/05_search/views.rb

@@ -0,0 +1,167 @@
+
+format do
+  view :search_count, cache: :never do
+    search_with_params.to_s
+  end
+
+  view :search_error, cache: :never do
+    sr_class = search_with_params.class.to_s
+    %(#{sr_class} :: #{search_with_params.message} :: #{card.content})
+  end
+
+  view :card_list, cache: :never do
+    if search_with_params.empty?
+      "no results"
+    else
+      search_with_params.map do |item_card|
+        nest_item item_card
+      end.join "\n"
+    end
+  end
+
+  view :no_search_results do
+    "no results"
+  end
+
+  def with_results
+    search_with_params.empty? ? render_no_search_results : yield
+  end
+end
+
+format :json do
+  AUTOCOMPLETE_LIMIT = 8 # number of name suggestions for autocomplete text fields
+
+  def item_cards
+    search_with_params
+  end
+
+  # NOCACHE because paging_urls is uncacheable hash and thus not safe to merge
+  view :molecule, cache: :never do
+    molecule.merge render_paging_urls
+  end
+
+  # TODO: design better autocomplete API
+  view :name_complete, cache: :never do
+    complete_search limit: AUTOCOMPLETE_LIMIT
+  end
+
+  view :name_match, cache: :never do
+    complete_or_match_search limit: AUTOCOMPLETE_LIMIT
+  end
+
+  def complete_or_match_search limit: AUTOCOMPLETE_LIMIT, start_only: false
+    starts_with = complete_search limit: limit
+    return starts_with if start_only
+
+    remaining_slots = limit - starts_with.size
+    return starts_with if remaining_slots.zero?
+    starts_with + match_search(not_names: starts_with, limit: remaining_slots)
+  end
+
+  def complete_search limit: AUTOCOMPLETE_LIMIT
+    card.search name_cql(limit).merge(complete_cql)
+  end
+
+  def match_search limit: AUTOCOMPLETE_LIMIT, not_names: []
+    card.search name_cql(limit).merge(match_cql(not_names))
+  end
+
+  def name_cql limit
+    { limit: limit, sort: "name", return: "name" }
+  end
+
+  def complete_cql
+    { complete: term_param }
+  end
+
+  def match_cql not_names
+    cql = { name_match: term_param }
+    cql[:name] = ["not in"] + not_names if not_names.any?
+    cql
+  end
+
+  def term_param
+    params[:term]
+  end
+end
+
+format :data do
+  view :card_list do
+    search_with_params.map do |item_card|
+      nest_item item_card
+    end
+  end
+end
+
+format :csv do
+  view :core, :core, mod: All::Csv::CsvFormat
+
+  view :card_list do
+    items = super()
+    if depth.zero?
+      title_row + items
+    else
+      items
+    end
+  end
+end
+
+format :html do
+  view :card_list, cache: :never do
+    with_results do
+      search_result_list "search-result-list" do |item_card|
+        card_list_item item_card
+      end
+    end
+  end
+
+  view :select_item, cache: :never do
+    wrap do
+      haml :select_item
+    end
+  end
+
+  before :select_item do
+    class_up "card-slot", "_filter-result-slot"
+  end
+
+  view :checkbox_list, cache: :never do
+    with_results do
+      search_result_list "_search-checkbox-list pr-2" do |item_card|
+        checkbox_item item_card
+      end
+    end
+  end
+
+  view :no_search_results do
+    wrap_with :div, "", class: "search-no-results"
+  end
+
+  private
+
+  def card_list_item item_card
+    nest_item item_card, size: voo.size do |rendered, item_view|
+      %(<div class="search-result-item item-#{item_view}">#{rendered}</div>)
+    end
+  end
+
+  def search_result_list klass
+    with_paging do
+      wrap_with :div, class: klass do
+        search_with_params.map do |item_card|
+          yield item_card
+        end
+      end
+    end
+  end
+
+  def checkbox_item item_card
+    subformat(item_card).wrap do
+      haml :checkbox_item, unique_id: unique_id, item_card: item_card
+    end
+  end
+
+  def closed_limit
+    [search_params[:limit].to_i, Card.config.closed_search_limit].min
+  end
+end

data/set/abstract/06_cql_search.rb

@@ -0,0 +1,91 @@
+include_set Abstract::Search
+
+def cql_hash
+  cache_query? ? (@cql_hash ||= cql_content) : cql_content
+end
+
+# override this to define search
+def cql_content
+  query = content
+  query = query.is_a?(Hash) ? query : parse_json_cql(query)
+  query.symbolize_keys
+end
+
+def item_type
+  type = cql_hash[:type]
+  return if type.is_a?(Array) || type.is_a?(Hash)
+  type
+end
+
+# for override, eg when required subqueries are known to be missing
+def skip_search?
+  false
+end
+
+def cache_query?
+  true
+end
+
+def parse_json_cql query
+  empty_query_error! if query.empty?
+  JSON.parse query
+rescue JSON::ParserError
+  raise Error::BadQuery, "Invalid JSON search query: #{query}"
+end
+
+def empty_query_error!
+  raise Error::BadQuery, "can't run search with empty content"
+end
+
+# These search methods are shared by card and format
+def search args={}
+  with_skipping args do
+    query = fetch_query(args)
+    # forces explicit limiting
+    # can be 0 or less to force no limit
+    raise "OH NO.. no limit" unless query.mods[:limit]
+    query.run
+  end
+end
+
+def with_skipping args
+  return yield unless skip_search?
+
+  args[:return] == :count ? 0 : []
+end
+
+def fetch_query args={}
+  @query = nil unless cache_query?
+  @query ||= {}
+  @query[args.to_s] ||= query(args.clone) # cache query
+end
+
+def query args={}
+  Query.new standardized_query_args(args), name
+end
+
+def standardized_query_args args
+  args = cql_hash.merge args.symbolize_keys
+  args[:context] ||= name
+  args
+end
+
+format do
+  def search_params
+    super.merge filter_and_sort_cql
+  end
+
+  def default_limit
+    card_content_limit || super
+  end
+
+  def card_content_limit
+    card.cql_hash&.dig :limit
+  end
+end
+
+format :html do
+  def default_limit
+    card_content_limit || super
+  end
+end

data/set/abstract/filterable.rb

@@ -0,0 +1,13 @@
+format :html do
+  def filterable filter_hash={}, html_opts={}
+    add_class html_opts, "_filterable _noFilterUrlUpdates"
+    html_opts[:data] ||= {}
+    html_opts[:data][:filter] = filter_hash
+    wrap_with :div, yield, html_opts
+  end
+
+  def filtering selector=nil
+    selector ||= "._filter-widget:visible"
+    wrap_with :div, yield, class: "_filtering", "data-filter-selector": selector
+  end
+end