Search test

Gemfile

@@ -150,3 +150,6 @@ gem 'open3'
 gem 'clipboard-rails'
 
 gem 'ajax-datatables-rails', '~> 1.0.0'
+
+# Elasticsearch client
+gem 'elasticsearch', '8.15.0'

Gemfile.lock

@@ -225,6 +225,14 @@ GEM
       activesupport (>= 4)
       edtf (>= 2.3, < 4)
       roman (~> 0.2.0)
+    elastic-transport (8.3.5)
+      faraday (< 3)
+      multi_json
+    elasticsearch (8.15.0)
+      elastic-transport (~> 8.3)
+      elasticsearch-api (= 8.15.0)
+    elasticsearch-api (8.15.0)
+      multi_json
     errbase (0.2.2)
     erubi (1.12.0)
     event_stream_parser (1.0.0)
@@ -698,6 +706,7 @@ DEPENDENCIES
   easy_translate
   edtf
   edtf-humanize
+  elasticsearch (= 8.15.0)
   factory_bot_rails
   flamegraph
   forty_facets

app/assets/stylesheets/components/shared.scss

@@ -378,6 +378,10 @@
   margin: 0 0 $gapSize / 2 0;
   font-size: $fontSizeStrong;
   font-family: $fontFamilyHead;
+  &.smaller {
+    font-size: $fontSizeSmall;
+    margin: 10px 0 0 0;
+  }
   li {
     margin: 0;
     display: inline-block;
@@ -1440,4 +1444,4 @@ button, .button, .dropdown dd a {
       color: $fgHover;
     }
   }
-}
+}

app/assets/stylesheets/sections/collection.scss

@@ -128,6 +128,9 @@
     }
     .progress { max-width: 300px; }
   }
+  &.search_result {
+    max-width: 90vw;
+  }
 }
 
 .hidden {

app/assets/stylesheets/sections/work.scss

@@ -46,6 +46,9 @@
   padding: $gapSize 0;
   display: inline-block;
   border-bottom: 1px dotted $borderColor;
+  &.search_result {
+    padding: 0;
+  }
   &_thumbnail {
     float: left;
     margin-right: $gapSize;
@@ -71,6 +74,9 @@
     padding-right: 0.5em;
     padding-bottom: 0.10em;
     padding-left: 0.5em;
+    &.search_result{
+      overflow-x: auto;
+    }
   }
   &_text p {
     margin: 0.3em 0;

app/controllers/collection_controller.rb

@@ -3,6 +3,7 @@ class CollectionController < ApplicationController
   include ContributorHelper
   include AddWorkHelper
   include CollectionHelper
+  include ElasticSearchable
 
   DEFAULT_WORKS_PER_PAGE = 15
 
@@ -139,12 +140,65 @@ def update_buttons
 
   end
 
+  def search # ElasticSearch version
+    search_page = (search_params[:page] || 1).to_i
+    @term = search_params[:term]
+
+    page_size = 10
+
+    if @collection.is_a?(Collection)
+      query_config = {
+        type: 'collection',
+        coll_id: @collection.id
+      }
+      @collection_filter = @collection
+    else
+      query_config = {
+        type: 'docset',
+        docset_id: @collection.id
+      }
+      @docset_filter = @collection
+    end
+
+    search_data = elastic_search_results(
+      @term,
+      search_page,
+      page_size,
+      search_params[:filter],
+      query_config
+    )
+
+    if search_data
+      inflated_results = search_data[:inflated]
+      @full_count = search_data[:full_count] # Used by All tab
+      @type_counts = search_data[:type_counts]
+
+      # Used for pagination, currently capped at 10k
+      #
+      # TODO: ES requires a scroll/search_after query for result sets larger
+      #       than 10k.
+      #
+      #       To setup support we just need to add a composite tiebreaker field
+      #       to the schemas
+      @filtered_count = [ 10000, search_data[:filtered_count] ].min
+
+      # Inspired by display controller search
+      @search_string = "\"#{@term || ""}\""
+      @search_results = WillPaginate::Collection.create(
+        search_page,
+        page_size,
+        @filtered_count) do |pager|
+          pager.replace(inflated_results)
+        end
+    end
+  end
+
   def facets
     collection = Collection.find(params[:collection_id])
     @metadata_coverages = collection.metadata_coverages
   end
 
-  def search
+  def facet_search
     mc = @collection.metadata_coverages.where(key: params['facet_search']['label']).first
     first_year = params['facet_search']['date'].split.first.to_i
     last_year = params['facet_search']['date'].split.last.to_i
@@ -819,4 +873,10 @@ def filtered_works
     works_scope = works_scope.distinct.paginate(page: params[:page], per_page: DEFAULT_WORKS_PER_PAGE)
     @works = works_scope
   end
+
+  def search_params
+    params.permit(:term, :page, :filter, :collection_id, :user_id)
+  end
+
+
 end

app/controllers/concerns/elastic_searchable.rb

@@ -0,0 +1,83 @@
+module ElasticSearchable
+  require 'elastic_util'
+  extend ActiveSupport::Concern
+
+  def elastic_search_results(query, page, page_size, filter, query_config)
+    return nil if query.nil?
+
+    search_types = ['collection', 'page', 'user', 'work']
+    # Narrow down types based on query_config
+    if query_config.present?
+      case query_config[:type]
+      when "org"
+        search_types = ['collection', 'page', 'work']
+      when "collection", "docset"
+        search_types = ['page', 'work']
+      when "work"
+        search_types = ['page']
+      end
+    end
+
+    if filter
+      count_query = ElasticUtil.gen_query(
+        current_user,
+        query,
+        search_types,
+        query_config,
+        page, page_size, true
+      )
+
+      # Need to run a count query for all types
+      # TODO: Could use msearch for one call to ES
+      resp = ElasticUtil.safe_search(
+        index: count_query[:indexes],
+        body: count_query[:query_body]
+      )
+
+      # No real inflation happens here but we get counts back
+      inflated_resp = ElasticUtil.inflate_response(resp)
+
+      full_count = inflated_resp[:full_count]
+      type_counts = inflated_resp[:type_counts]
+
+      filtered_query = ElasticUtil.gen_query(
+        current_user,
+        query,
+        [filter],
+        query_config,
+        page, page_size
+      )
+
+      filtered_resp = ElasticUtil.safe_search(
+        index: filtered_query[:indexes],
+        body: filtered_query[:query_body]
+      )
+
+      # Actual object inflation for the filtered set
+      inflated_resp = ElasticUtil.inflate_response(filtered_resp)
+
+      # Blend all/filtered for display
+      return {
+        inflated: inflated_resp[:inflated],
+        full_count: full_count,
+        filtered_count: inflated_resp[:filtered_count],
+        type_counts: type_counts
+      }
+    else
+      generated_query = ElasticUtil.gen_query(
+        current_user,
+        query,
+        ['collection', 'page', 'user', 'work'],
+        query_config,
+        page, page_size
+      )
+
+      resp = ElasticUtil.safe_search(
+        index: generated_query[:indexes],
+        body: generated_query[:query_body]
+      )
+
+      return ElasticUtil.inflate_response(resp)
+    end
+  end
+end