Basic working RI support in UI

app/controllers/application_controller.rb

@@ -681,10 +681,6 @@ def get_recent_mappings
     return recent_mappings
   end
 
-  def get_resource_index_resources
-    return LinkedData::Client::HTTP.get(RI_RESOURCES_URI)
-  end
-
   def get_resource_index_annotation_stats
     begin
       stats_hash = Rails.cache.read(RI_STATS_URI)

app/controllers/resource_index_controller.rb

@@ -26,7 +26,7 @@ class ResourceIndexController < ApplicationController
   before_filter :set_encoding
 
   def index
-    @resources ||= get_resource_index_resources # application_controller
+    @resources ||= LinkedData::Client::ResourceIndex.resources
     @ri_ontologies = LinkedData::Client::Models::Ontology.all(include: "acronym,administeredBy,group,hasDomain,name,notes,projects,reviews,summaryOnly,viewingRestriction")
     @ont_ids = []
     @ont_acronyms = {}
@@ -61,69 +61,32 @@ def search_classes
     render :text => classes_json
   end
 
-
   def resources_table
     create()
   end
 
   def create
     @bp_last_params = params
-    @classes = params[:classes]
-    uri = getCountsURI(params)
-    @elements = []
-    @elements_page_count = 0
-    @error = nil
-    while true
-      begin
-        # Resource index can be very slow and timeout, so parse_json includes one retry.
-        ranked_elements_page = parse_json(uri) # See application_controller.rb
-      rescue Exception => e
-        @error = e.message
-        LOG.add :error, @error
-        break
-      end
-      # Might generate missing method exception here on a 404 response.
-      @error = ranked_elements_page['error']
-      if @error.nil?
-        @elements.concat ranked_elements_page['collection']
-        break if @elements_page_count >= ranked_elements_page['pageCount']
-        break if ranked_elements_page['nextPage'].nil?
-        uri = ranked_elements_page['nextPage']
-        @elements_page_count += 1
-      else
-        LOG.add :error, @error
-        break
-      end
-    end
-    if @error.nil?
-      # Sort ranked elements list by resource name
-      @resources ||= get_resource_index_resources # application_controller
-      @resources_hash ||= resources2hash(@resources)  # required in partial 'resources_results'
-      resources_map = resources2map_id2name(@resources)
-      @elements.sort! {|a,b| resources_map[a['acronym']].downcase <=> resources_map[b['acronym']].downcase}
-      #@elements = convert_for_will_paginate(@elements)
-    end
+    @classes = lookup_classes(params)
+    @counts = LinkedData::Client::ResourceIndex.counts(@classes)
+
+    @resources ||= LinkedData::Client::ResourceIndex.resources # application_controller
+    @resources_hash ||= resources2hash(@resources)  # required in partial 'resources_results'
+
     render :partial => "resources_results"
   end
 
-  #
-  #
-  # TODO: Revise pagination to work with stagedata paged results object.
-  # Note: the create() method gets all the paged results, see ranked_elements_page above.
-  #
-  #
   def results_paginate
-    offset = (params[:page].to_i - 1) * params[:limit].to_i
-    ranked_elements = ri.ranked_elements(params[:conceptids], :acronyms => [params[:acronym]], :offset => offset, :limit => params[:limit])
-
-    # There should be only one resource returned because we pass it in above
-
-    @resources ||= get_resource_index_resources # application_controller
+    params[:page]  ||= 1
+    params[:limit] ||= 10
+    @classes = lookup_classes(params)
+    @documents = LinkedData::Client::ResourceIndex.documents(params[:acronym], @classes, page: params[:page], pagesize: params[:limit])
+    @resource_results = ResourceIndexResultPaginatable.new(@documents)
+    @acronym = params[:acronym]
+
+    @resources ||= LinkedData::Client::ResourceIndex.resources
     @resources_hash ||= resources2hash(@resources)  # required in partial 'resources_results'
 
-    @resource_results = convert_for_will_paginate(ranked_elements.resources)[0]
-    @concept_ids = params[:conceptids]
-
     render :partial => "resource_results"
   end
 
@@ -146,8 +109,6 @@ def element_annotations
       LOG.add :error, @error
     end
     # Might generate missing method exception here on a 404 response.
-    #binding.pry
-    #@error = @annotations['error']  # not sure what this looks like on a 404 yet
     if @error.nil?
       @annotations.each do |a|
         field = a['elementField']
@@ -160,9 +121,7 @@ def element_annotations
     render :json => positions
   end
 
-
-private
-
+  private
 
   def resources2hash(resourcesList)
     resources_hash = {}
@@ -202,6 +161,19 @@ def getCountsURI(params)
     return "#{REST_URI}/resource_index/counts" + "?" + classesArgs.join('&')
   end
 
+  def lookup_classes(params)
+    classes = []
+    if params[:classes].kind_of?(Hash)
+      classesHash = params[:classes]
+      classesHash.each do |ont_uri, cls_uris|
+        cls_uris = cls_uris.is_a?(Array) ? cls_uris : [cls_uris]
+        ont = LinkedData::Client::Models::Ontology.find(ont_uri)
+        cls_uris.each {|cls_id| classes << ont.explore.single_class(cls_id)}
+      end
+    end
+    return classes
+  end
+
   def set_encoding
     response.headers['Content-type'] = 'text/html; charset=ISO-8859-1'
   end

app/helpers/resource_index_helper.rb

@@ -54,14 +54,14 @@ def element_text(element, weight)
     end
   end
 
-  def field_text(field)
+  def field_text(text, field_info)
     # Adapted from element_text for the new API data. (TODO: element_text could disappear if this works?)
-    onts = field['associatedOntologies']
+    onts = field_info[:ontology]
     # onts is a list of ontologies associated with an element field.  It may be empty.
     # If it contains ontology data, it may contain an ontology id (int > 0) and we should return a link.
     # We'll resolve the link to a label using JS once the page loads.
-    if onts.empty?
-      h(field['text'])
+    if !onts || onts.empty?
+      h(text)
     else
       # TODO
       # TODO

app/models/resource_index_result_paginatable.rb

@@ -5,18 +5,16 @@ def initialize(hash)
     return if hash.nil?
 
     # Our custom attributes
-    self.totalResults = hash[:totalResults]
-    self.offset = hash[:offset]
-    self.limit = hash[:limit]
-    self.acronym = hash[:acronym]
+    self.totalResults = hash.pageCount * hash.collection.length
+    self.offset = hash.page * hash.collection.length
+    self.limit = hash.collection.length
 
     # Fill out attributes needed by will_paginate
-    page_number = (self.offset / self.limit) + 1
-    @current_page = page_number
+    @current_page = hash.page
     @per_page = self.limit
     self.total_entries = self.totalResults
 
     # Put the array elements in place
-    self.replace(hash[:elements])
+    self.replace(hash.collection)
   end
 end

app/views/resource_index/_resource_results.html.haml

@@ -1,19 +1,17 @@
--acronym = @resource_results['acronym']
-%div.element_results.paginate_ajax{:id => "#{acronym}_results"}
-  -resource_data = @resources_hash[acronym]
-  -resource_url = resource_data.include?(:resourceElementURL) ? resource_data[:resourceElementURL] : ""
-  -@resource_results['elements'].each do |element|
+%div.element_results{:id => "#{@acronym}_results"}
+  -resource_data = @resources_hash[@acronym]
+  -resource_url = resource_data.include?(:lookupURL) ? resource_data[:lookupURL] : "" rescue binding.pry
+  -@resource_results.each do |document|
+    -element_id = document['documentId']
     // this gsub generates: active_support/core_ext/string/output_safety.rb:22: warning: regexp match /.../n against to UTF-8 string
-    -element_id = element['id']
     -element_id_clean = CGI.escape(element_id.gsub(/[^0-9A-Za-z]/, ""))
     -element_url = resource_url + element_id
-    -element_data = {:clean_element_id => element_id_clean, :element_id => CGI.escape(element_id), :resource_id => acronym}
-    -fields_hash = element['fields']
-    -fields_hash.delete_if {|k,v| v.nil? }  # remove the 'links' and 'context', which have nil values.
-    -field_main = fields_hash[ resource_data[:mainContext] ] # extract the 'main' field.
+    -element_data = {:clean_element_id => element_id_clean, :element_id => CGI.escape(element_id), :resource_id => @acronym}
+    -fields_hash = document.to_h.delete_if {|k,v| v.nil? || k == :documentId}
+    -field_main = fields_hash[ resource_data[:mainField].to_sym ]
     %div.element_result{:data => {:element_id => element_id_clean}}
       %div{:id => "#{element_id_clean}_link"}
-        %a{:href => "javascript:void(0);", :class => "show_element_details", :data => element_data}= field_main['text']
+        %a{:href => "javascript:void(0);", :class => "show_element_details", :data => element_data}= field_main
       %div.not_visible.element_results{:id => element_id_clean+"_text", :data => {:highlighted => false}}
         %div.ri_legend_container
           %div.ri_legend
@@ -26,19 +24,18 @@
             %div.hierarchy.highlight_box  
             %div.clearing
         %div.element_text
-          -fields_sorted = fields_hash.sort_by { |k,v| v['weight'] }.reverse  # returns list like [ [k,v], ...]
+          -fields_sorted = fields_hash.sort_by { |k,v| resource_data[:fields][k].weight }.reverse rescue binding.pry # returns list like [ [k,v], ...]
           -fields_sorted.each do |field_list|  # field_list contains [ string, hash ]
             -field_name = field_list[0]
             -field_data = field_list[1]
-            %h4= field_name.split("_").drop(1).join(" ").capitalize
-            %p{:data => {:context_name => field_name}}= field_text(field_data)  # see resource_index_helper.rb
+            %h4= field_name.to_s.split("_").drop(1).join(" ").capitalize
+            %p{:data => {:context_name => field_name}}= field_text(field_data, resource_data[:fields][field_name])  # see resource_index_helper.rb
           %span{:class => "element_info"}
             %a{:href => element_url, :target => "_blank"} view source record
-  =# will_paginate @resource_results, :update => "#{acronym}_results",
-    :params => { :offset => @resource_results['offset'],
-      :limit => @resource_results['limit'],
-      :acronym => acronym,
-      :classes => @classes,
-      :controller => "resource_index",
-      :action => "results_paginate" }
+  = will_paginate @resource_results, :update => "#{@acronym}_results",
+    :params => { :offset => @resource_results.offset,
+    :limit => @resource_results.limit,
+    :acronym => @acronym,
+    :controller => "resource_index",
+    :action => "results_paginate" }.merge(LinkedData::Client::ResourceIndex.class_params_hash(@classes))
 

app/views/resource_index/_resources_results.html.haml

@@ -20,11 +20,11 @@
         %th.count % Matched
         %th.count Total Records
     %tbody
-      -@elements.each do |r|
-        -acronym = r['acronym']
-        -resource_data = @resources_hash[acronym]
+      -@counts.each do |acronym, count|
+        -next unless count
+        -resource_data = @resources_hash[acronym.to_s]
         -resource_name = resource_data[:name]
-        -total_results = r['count'].to_i
+        -total_results = count
         -total_elements = resource_data[:count]
         -total_percent = (BigDecimal(total_results) / BigDecimal(total_elements)) * BigDecimal.new(100)
         -total_percent = total_percent < 0.01 ? '< 0.01%' : sprintf('%0.2f%', total_percent)
@@ -49,13 +49,21 @@
     %a.h2_link{:href => "javascript:void(0);", :id => "show_all_resources"} show all resources
 
 %div#resource_results
-  -@elements.each do |r|
-    -acronym = r['acronym']
-    -@resource_results = r
+  -@counts.each do |acronym, count|
+    - next unless count
+    /-@resource_results = r #TODO figure out how to get the resource data via
     %div.resource_info.resource_details.not_visible{:id => "resource_info_#{acronym}"}
       %div.resource_image
-        %img{:src => @resources_hash[acronym][:resourceLogo], :class => "resource_image"}
-      =render :partial => "resource_results"
+        %img{:src => @resources_hash[acronym.to_s][:logo], :class => "resource_image"}
+      - if count > 0
+        - @documents = LinkedData::Client::ResourceIndex.documents(acronym, @classes, page: 1, pagesize: 10)
+        - @resource_results = ResourceIndexResultPaginatable.new(@documents)
+        - @acronym = acronym.to_s
+
+        %div.paginate_ajax
+          %a{class: "get_via_ajax", href: "/resource_index/results_paginate?acronym=#{acronym}&#{LinkedData::Client::ResourceIndex.class_params(@classes)}"}
+      - else
+        No results
       %div.clearing
 
 %div.clearing