Initial tabbed Primo/TIMDEX interface

Why these changes are being introduced:

USE UI needs affordances to switch between results
from different sources. Primo results should be
the default view.

Relevant ticket(s):

* [USE-31](https://mitlibraries.atlassian.net/browse/USE-31)
* [TIMX-549](https://mitlibraries.atlassian.net/browse/TIMX-549)

How this addresses that need:

* Integrates Primo search into the controller and
view layers
* Adds Turbo frame 'tabs' to switch between Primo
and TIMDEX results.

Side effects of this change:

* Maintaining separate views for each result type
is probably not ideal, but I'm accepting it as a
risk until we normalize TIMDEX records similarly
to how we normalize Primo.
* Several tests have been skipped for features
that are no longer relevant to USE UI, but are
core to GDT. We will need to revise our overall
test strategy such that these features are tested
as part of GDT.
* FRBRized full record links don't always work. It
the method we use breaks FRBR links for CDI
records. Predictably, Ex Libris documentation on
FRBR does not address this issue. We might decide
to forgo FRBR links in general, or perhaps limit
them by content type (assuming book results always
come from Alma).
* Pagination is not yet implemented.

Author: jazairi

app/controllers/search_controller.rb

@@ -15,59 +15,108 @@ def results
     # inject session preference for boolean type if it is present
     params[:booleanType] = cookies[:boolean_type] || 'AND'
 
-    # hand off to Enhancer chain
-    @enhanced_query = Enhancer.new(params).enhanced_query
+    # Determine which tab to load - default to primo unless gdt is enabled
+    @active_tab = if Flipflop.enabled?(:gdt)
+                    'gdt'  # Keep existing GDT behavior unchanged
+                  else
+                    params[:tab] || 'primo'  # Default to primo for new tabbed interface
+                  end
+
+    # Route to appropriate search based on active tab
+    if Flipflop.enabled?(:gdt)
+      # Keep existing GDT behavior unchanged
+      load_gdt_results
+    else
+      case @active_tab
+      when 'primo'
+        load_primo_results
+      when 'timdex'
+        load_timdex_results
+      end
+    end
+  end
 
-    # hand off enhanced query to builder
-    query = QueryBuilder.new(@enhanced_query).query
+  private
 
-    # Create cache key for this query
-    # Sorting query hash to ensure consistent key generation regardless of the parameter order
-    sorted_query = query.sort_by { |k, v| k.to_sym }.to_h
-    cache_key = Digest::MD5.hexdigest(sorted_query.to_s)
+  def load_gdt_results
+    @enhanced_query = Enhancer.new(params).enhanced_query
+    query = QueryBuilder.new(@enhanced_query).query
 
-    # builder hands off to wrapper which returns raw results here
-    # We are using two difference caches to allow for Geo and USE to be cached separately. This ensures we don't have
-    # cache key collission for these two different query types. In practice, the likelihood of this happening is low,
-    # as the query parameters are different for each type and they won't often be run with the same cache backend other
-    # than locally, but this is a safeguard.
-    # The response type is a GraphQL::Client::Response, which is not directly serializable, so we convert it to a hash.
-    response = if Flipflop.enabled?(:gdt)
-                 Rails.cache.fetch("#{cache_key}/geo", expires_in: 12.hours) do
-                   raw = execute_geospatial_query(query)
-                   {
-                     data: raw.data.to_h,
-                     errors: raw.errors.details.to_h
-                   }
-                 end
-               else
-                 Rails.cache.fetch("#{cache_key}/use", expires_in: 12.hours) do
-                   raw = TimdexBase::Client.query(TimdexSearch::BaseQuery, variables: query)
-                   {
-                     data: raw.data.to_h,
-                     errors: raw.errors.details.to_h
-                   }
-                 end
-               end
+    response = cache_timdex_query(query)
 
     # Handle errors
     @errors = extract_errors(response)
-
-    # Analayze results
-    # The @pagination instance variable includes info about next/previous pages (where they exist) to assist the UI.
     @pagination = Analyzer.new(@enhanced_query, response).pagination if @errors.nil?
-
-    # Display results
     @results = extract_results(response)
     @filters = extract_filters(response)
   end
 
-  private
+  def load_primo_results
+    @enhanced_query = Enhancer.new(params).enhanced_query
+    @errors = nil
+    @results = []
+    @pagination = nil
+
+    begin
+      primo_search = PrimoSearch.new
+      per_page = params[:per_page] || 20
+      primo_response = primo_search.search(params[:q], per_page)
+      
+      @results = NormalizePrimoResults.new(primo_response, params[:q]).normalize
+      
+      # Basic pagination for now.
+      if @results.present?
+        @pagination = {
+          hits: @results.count,
+          start: 1,
+          end: @results.count
+        }
+      end
+      
+    rescue StandardError => e
+      @errors = handle_primo_errors(e)
+    end
+  end
+
+  def load_timdex_results
+    @enhanced_query = Enhancer.new(params).enhanced_query
+    query = QueryBuilder.new(@enhanced_query).query
+    response = cache_timdex_query(query)
+
+    @errors = extract_errors(response)
+    @pagination = Analyzer.new(@enhanced_query, response).pagination if @errors.nil?
+    @results = extract_results(response)
+  end
 
   def active_filters
     ENV.fetch('ACTIVE_FILTERS', '').split(',').map(&:strip)
   end
 
+  def cache_timdex_query(query)
+    # Create cache key for this query
+    # Sorting query hash to ensure consistent key generation regardless of the parameter order
+    sorted_query = query.sort_by { |k, v| k.to_sym }.to_h
+    cache_key = Digest::MD5.hexdigest(sorted_query.to_s)
+
+    # builder hands off to wrapper which returns raw results here
+    # We are using two difference caches to allow for Geo and USE to be cached separately. This ensures we don't have
+    # cache key collision for these two different query types. In practice, the likelihood of this happening is low,
+    # as the query parameters are different for each type and they won't often be run with the same cache backend other
+    # than locally, but this is a safeguard.
+    # The response type is a GraphQL::Client::Response, which is not directly serializable, so we convert it to a hash.
+    Rails.cache.fetch("#{cache_key}/#{@active_tab}", expires_in: 12.hours) do
+      raw = if @active_tab == 'gdt'
+              execute_geospatial_query(query)
+            elsif @active_tab == 'timdex'
+              TimdexBase::Client.query(TimdexSearch::BaseQuery, variables: query)
+            end
+      {
+        data: raw.data.to_h,
+        errors: raw.errors.details.to_h
+      }
+    end
+  end
+
   def execute_geospatial_query(query)
     if query['geobox'] == 'true' && query[:geodistance] == 'true'
       TimdexBase::Client.query(TimdexSearch::AllQuery, variables: query)
@@ -214,4 +263,16 @@ def validate_geobox_values!
     flash[:error] = 'Maximum latitude cannot exceed minimum latitude.'
     redirect_to root_url
   end
+
+  def handle_primo_errors(error)
+    Rails.logger.error("Primo search error: #{error.message}")
+    
+    if error.is_a?(ArgumentError)
+      [{ 'message' => 'Primo search is not properly configured.' }]
+    elsif error.is_a?(HTTP::TimeoutError)
+      [{ 'message' => 'The Primo service is currently slow to respond. Please try again.' }]
+    else
+      [{ 'message' => error.message }]
+    end
+  end
 end