atrium 0.0.1.alpha

data/lib/atrium/collections_helper.rb

@@ -0,0 +1,139 @@
+module Atrium::CollectionsHelper
+
+  # Standard display of a facet value in a list. Used in both _facets sidebar
+  # partial and catalog/facet expanded list. Will output facet value name as
+  # a link to add that to your restrictions, with count in parens.
+  # first arg item is a facet value item from rsolr-ext.
+  # options consist of:
+  # :suppress_link => true # do not make it a link, used for an already selected value for instance
+  def get_browse_facet_path(facet_solr_field, value, browse_facets, exhibit_number, exhibit_id, opts={})
+    p = HashWithIndifferentAccess.new
+    p.merge!(:f=>params[:f].dup) if params[:f]
+    if params[:collection_id]
+      #p.merge!(:id=>params[:collection_id])
+      p.merge!(:collection_id=>params[:collection_id])
+    elsif params[:id] && params[:controller] == "atrium_collections"
+      #p.merge!(:id=>params[:id])
+      p.merge!(:collection_id=>params[:id])
+      #p.merge!(:controller=>params[:controller])
+    end
+    #if params[:edit_showcase]
+    #  p.merge!(:edit_showcase=>true)
+    #end
+    p.merge!(:id=>exhibit_id)
+    p = remove_related_facet_params(facet_solr_field, p, browse_facets, exhibit_number)
+    p = add_browse_facet_params(facet_solr_field,value,p)
+    #it should only return a path for current facet selection plus parent selected values so if generating for multiple levels, than need to ignore some potentially
+    #params[:action] == "edit" ? edit_atrium_collection_path(p.merge!({:class=>"browse_facet_select"})) : atrium_collection_path(p.merge!({:class=>"browse_facet_select"}))
+    atrium_exhibit_path(p.merge!({:class=>"browse_facet_select"}))
+  end
+
+  def add_browse_facet_params(field, value, p=HashWithIndifferentAccess.new)
+    p[:f]||={}
+    p[:f][field] ||= []
+    p[:f][field].push(value)
+    p
+  end
+
+  def get_exhibit_set_number(exhibit_id)
+    Atrium::Exhibit.find(exhibit_id).set_number
+  end
+
+  # Standard display of a SELECTED facet value, no link, special span
+  # with class, and 'remove' button.
+  def get_selected_browse_facet_path(facet_solr_field, value, browse_facets, exhibit_number, exhibit_id, opts={})
+    value = [value] unless value.is_a? Array
+    p = HashWithIndifferentAccess.new
+    p.merge!(:f=>params[:f].dup) if params[:f]
+    p = remove_related_facet_params(facet_solr_field, p, browse_facets, exhibit_number)
+    if params[:collection_id]
+      p.merge!(:id=>params[:collection_id])
+      p.merge!(:collection_id=>params[:collection_id])
+    elsif params[:id] && params[:controller] == "atrium_collections"
+      p.merge!(:id=>params[:id])
+      p.merge!(:collection_id=>params[:id])
+      p.merge!(:controller=>params[:controller])
+    end
+    #if params[:edit_showcase]
+    #  p.merge!(:edit_showcase=>true)
+    #end
+    p.merge!(:id=>exhibit_id)
+   # params[:action] == "edit" ? edit_atrium_collection_path(p) : atrium_collection_path(p)
+    atrium_exhibit_path(p)
+  end
+
+  #Remove current selected facet plus any child facets selected
+  def remove_related_facet_params(solr_facet_field, p, browse_facets, exhibit_number)
+    if params[:exhibit_number] && params[:exhibit_number].to_i != exhibit_number.to_i
+      p.delete(:f) if p[:f]
+    elsif browse_facets.include?(solr_facet_field)
+      #iterate through browseable facets from current on down
+      index = browse_facets.index(solr_facet_field)
+      if p[:f]
+        browse_facets.slice(index, browse_facets.length - index).each do |f|
+          p[:f].delete(f)
+        end
+      end
+    end
+    p
+  end
+
+  def get_selected_browse_facets(browse_facets)
+    selected = {}
+    if params[:f]
+      browse_facets.each do |facet|
+        selected.merge!({facet.to_sym=>params[:f][facet].first}) if params[:f][facet]
+      end
+    end
+    selected
+  end
+
+  def grouped_result_count(response, facet_name=nil, facet_value=nil)
+    if facet_name && facet_value
+      facet = response.facets.detect {|f| f.name == facet_name}
+      facet_item = facet.items.detect {|i| i.value == facet_value} if facet
+      count = facet_item ? facet_item.hits : 0
+    else
+      count = response.docs.total
+    end
+    pluralize(count, 'document')
+  end
+
+  def get_collections_list
+    Atrium::Collection.find(:all)
+  end
+
+  # Return the link to browse an collection
+  # @return [String] a formatted url to be used in href's etc.
+  def browse_collection_link
+    atrium_collection_path(get_collection_id)
+  end
+
+  # Returns the current collection id in the parameters.
+  # If the current controller is atrium_collections it expects the collection id to be in params[:id]
+  # Otherwise, it expects it to be in params[:collection_id]
+  # @return [String] the collection id
+  def get_collection_id
+    params[:controller] == "atrium_collections" ? params[:id] : params[:collection_id]
+  end
+
+  # Return the link to edit an collection
+  # @param [String] a css class to use in the link if necessary
+  # @return [String] a formatted url to be used in href's etc.
+  def edit_collection_link(css_class=nil)
+    edit_atrium_collection_path(get_collection_id, :class => css_class, :render_search=>"false")
+  end
+
+  def get_customize_page_path
+    if params[:controller] == "atrium/exhibits"
+      exhibit=Atrium::Exhibit.find(params[:id])
+      path = new_atrium_exhibit_showcases_path(exhibit, :facet_selection => params[:f])
+    elsif params[:controller] == "atrium/collections"
+      collection=Atrium::Collection.find(params[:id])
+      path= new_atrium_collection_showcases_path(collection)
+    end
+    return path
+  end
+
+end
+

data/lib/atrium/controller.rb

@@ -0,0 +1,10 @@
+require 'atrium/layout_helper'
+
+# Adds behaviors that Atrium needs all controllers to have. (mostly view helpers)
+module Atrium::Controller
+  include Atrium::LayoutHelper
+
+  def self.included(base)
+    base.helper 'atrium/solr_helper'
+  end
+end

data/lib/atrium/descriptions_helper.rb

@@ -0,0 +1,23 @@
+module Atrium::DescriptionsHelper
+
+  def get_description_for_showcase(showcase)
+    solr_desc_arr=[]
+    showcase.descriptions.each do |desc|
+      solr_desc_arr<< desc.description_solr_id unless desc.description_solr_id.blank?
+    end
+    @description_hash={}
+    unless solr_desc_arr.empty?
+      p = params.dup
+      params.delete :f
+      params.delete :q
+      desc_response, desc_documents = get_solr_response_for_field_values("id",solr_desc_arr.uniq)
+      desc_documents.each do |doc|
+        @description_hash[doc["id"]]= doc["description_content_s"].blank? ? "" : doc["description_content_s"].first
+      end
+      params.merge!(:f=>p[:f])
+      params.merge!(:q=>p[:q])
+    end
+    return @description_hash
+  end
+
+end

data/lib/atrium/engine.rb

@@ -0,0 +1,12 @@
+require "atrium"
+require "rails"
+module Atrium
+  class Engine < Rails::Engine
+
+    # AtriumHelper is needed by all helpers, so we inject it
+    # into action view base here.
+    initializer 'atrium.helpers' do |app|
+      ActionView::Base.send :include, Atrium::BaseHelper
+    end
+  end
+end

data/lib/atrium/layout_helper.rb

@@ -0,0 +1,13 @@
+# This module is a controller level mixin that helps render the appropriate layout for the given context
+module Atrium::LayoutHelper
+  def current_layout
+    @atrium_collection ? @atrium_collection.theme_path : 'atrium'
+  end
+
+  def collection_theme_if_present
+    unless params[:collection_id].blank?
+      @atrium_collection ||= Atrium::Collection.find(params[:collection_id])
+    end
+    current_layout
+  end
+end

data/lib/atrium/routes.rb

@@ -0,0 +1,99 @@
+# -*- encoding : utf-8 -*-
+module Atrium
+  class Routes
+
+    def initialize(router, options)
+      @router = router
+      @options = options
+    end
+
+    def draw
+      route_sets.each do |r|
+        self.send(r)
+      end
+    end
+
+    protected
+
+    def add_routes &blk
+      @router.instance_exec(@options, &blk)
+    end
+
+    def route_sets
+      (@options[:only] || default_route_sets) - (@options[:except] || [])
+    end
+
+    def default_route_sets
+      [:atrium_collections, :catalog, :get]
+    end
+
+    module RouteSets
+
+      def atrium_collections
+        add_routes do |options|
+          namespace :atrium do
+            resources :collections, :exhibits do
+              resource :showcases, :only => [:new]
+            end
+            resources :showcases, :only => [:show]
+            resources :descriptions do
+              resource :essays
+            end
+          end
+          match 'atrium_collections/:id/exhibit_order',                              :to => 'atrium/collection_exhibit_order#index',      :as => 'atrium_collection_exhibit_order'
+          match 'atrium_collections/:id/exhibit_order/update',                       :to => 'atrium/collection_exhibit_order#update',     :as => 'update_atrium_collection_exhibit_order', :via => :post
+          match 'atrium_collections/:collection_id/catalog',                         :to => 'catalog#index',                              :as => 'atrium_collection_home', :via => :get
+          match 'atrium_collections/configure/:id',                                  :to => 'atrium/collections#home_page_text_config',   :as => 'atrium_collection_text_configure'
+          match 'atrium_collections/set_scope/:id',                                  :to => 'atrium/collections#set_collection_scope',    :as => 'atrium_set_collection_scope'
+          match 'atrium_collections/unset_scope/:id',                                :to => 'atrium/collections#unset_collection_scope',  :as => 'atrium_unset_collection_scope'
+          match 'atrium_exhibits/:id/facet_order',                                   :to => 'atrium/exhibit_facet_order#index',           :as => 'atrium_exhibit_facet_order'
+          match 'atrium_exhibits/:id/facet_order/update',                            :to => 'atrium/exhibit_facet_order#update',          :as => 'update_atrium_exhibit_facet_order', :via => :post
+          match 'atrium_exhibits/set_scope/:id',                                     :to => 'atrium/exhibits#set_exhibit_scope',          :as => 'atrium_set_exhibit_scope'
+          match 'atrium_exhibits/unset_scope/:id',                                   :to => 'atrium/exhibits#unset_exhibit_scope',        :as => 'atrium_unset_exhibit_scope'
+          match 'atrium_exhibits/:id/showcases/:showcase_id',                         :to => 'atrium/exhibits#show',                      :as => 'atrium_exhibit_showcase'
+          match 'atrium_showcases/featured/:id',                                     :to => 'atrium/showcases#featured',                  :as => 'atrium_showcase_featured'
+          match 'atrium_showcases/refresh/:id',                                      :to => 'atrium/showcases#refresh_showcase',          :as => 'atrium_showcase_refresh'
+          match 'atrium_collections/:collection_id/catalog/:id',                     :to => 'catalog#show',                               :as => 'atrium_collection_catalog'
+          match 'atrium_collections/:collection_id/browse/:id',                      :to => 'catalog#show',                               :as => 'atrium_collection_browse', :defaults=>{:atrium_collection_browse=>true}
+          match 'atrium_collections/:collection_id/exhibits/:exhibit_id/browse/:id', :to => 'catalog#show',                               :as => 'atrium_collection_exhibit_browse', :defaults=>{:atrium_exhibit_browse=>true}
+          match 'atrium_collections/:id/showcases/:showcase_id',                     :to => 'atrium/collections#show',                    :as => 'atrium_collection_showcase'
+          match 'atrium_exhibits/:exhibit_id/browse/:id',                            :to => 'catalog#show',                               :as => 'atrium_exhibit_browse', :defaults=>{:atrium_exhibit_browse=>true}
+          match 'atrium_showcases/:showcase_id/descriptions',                        :to => 'atrium/descriptions#index',                  :as => 'atrium_descriptions', :via => :get
+          match 'atrium_showcases/:showcase_id/descriptions',                        :to => 'atrium/descriptions#create',                 :as => 'atrium_descriptions', :via => :post
+          match 'atrium_showcases/:showcase_id/descriptions/new',                    :to => 'atrium/descriptions#new',                    :as => 'new_atrium_description'
+          match 'atrium/customization/start',                                        :to => 'atrium/customization#start',                 :as => 'start_atrium_customization'
+          match 'atrium/customization/stop',                                         :to => 'atrium/customization#stop',                  :as => 'stop_atrium_customization'
+          match 'atrium_descriptions/add/:showcase_id',                              :to => 'atrium/descriptions#add_from_solr',          :as => 'atrium_descriptions_add'
+          match 'atrium_descriptions/link/:showcase_id',                             :to => 'atrium/descriptions#save_ids_to_descriptions',      :as => 'atrium_descriptions_link'
+        end
+      end
+
+      def catalog
+        add_routes do |options|
+          match 'catalog/:id/edit', :to => 'catalog#edit', :as => 'edit_catalog'
+          # The delete method renders a confirmation page with a button to submit actual destroy request
+          match 'catalog/:id/delete', :to => 'catalog#delete', :as => 'delete_catalog'
+	  ### The rest of these routes are defined in blacklight
+          #resources :catalog, :id=> /.+/
+         # resources :catalog, :only => [:index, :show], :controller => "hydra_head/catalog", :path_prefix => HydraHead::Engine.config.mount_at, :as => "hydra_head", :id=> /.+/
+          #match 'catalog/:id', :to => "hydra_head/catalog#show", :path_prefix => HydraHead::Engine.config.mount_at, :as => "catalog", :id => /.+/
+          #match 'catalog/:id', :to => "hydra_head/catalog#show", :id => /.+/
+          # match 'about', :to => 'catalog#about', :as => 'about'
+        end
+      end
+
+
+      def get
+        add_routes do |options|
+          resources :get, :only=>:show
+        end
+      end
+
+
+    end
+    include RouteSets
+
+#match 'generic_contents_object/content/:container_id', :to => 'generic_content_objects#create', :as => 'generic_content_object', :via => :post
+  end
+end
+

data/lib/atrium/solr_helper.rb

@@ -0,0 +1,440 @@
+# This module is a controller level mixin that uses Blacklight::SolrHelper to make calls to solr in an collection context
+module Atrium::SolrHelper
+
+  def grouped_result_count(response, facet_name=nil, facet_value=nil)
+    if facet_name && facet_value
+      facet = response.facets.detect {|f| f.name == facet_name}
+      facet_item = facet.items.detect {|i| i.value == facet_value} if facet
+      count = facet_item ? facet_item.hits : 0
+    else
+      count = response.docs.total
+    end
+    pluralize(count, 'document')
+  end
+
+  # Return the link to browse an collection
+  # @return [String] a formatted url to be used in href's etc.
+  def browse_collection_link
+    atrium_collection_path(get_collection_id)
+  end
+
+  # Returns the current collection id in the parameters.
+  # If the current controller is atrium_collections it expects the collection id to be in params[:id]
+  # Otherwise, it expects it to be in params[:collection_id]
+  # @return [String] the collection id
+  def get_collection_id
+    params[:controller] == "atrium_collections" ? params[:id] : params[:collection_id]
+  end
+
+  # Return the link to edit an collection
+  # @param [String] a css class to use in the link if necessary
+  # @return [String] a formatted url to be used in href's etc.
+  def edit_collection_link(css_class=nil)
+    edit_atrium_collection_path(get_collection_id, :class => css_class, :render_search=>"false")
+  end
+
+  # Returns the current atrium_collection instance variable
+  # @return [Atrium::Collection]
+  def atrium_collection
+    @atrium_collection
+  end
+
+  # Returns the current exhibit instance variable
+  # @return [Atrium::Exhibit]
+  def exhibit
+    @exhibit
+  end
+
+  # Returns the current browse_levels instance variable
+  # @return [Array] Array of Atrium::BrowseLevel for current Atrium::Collection
+  def exhibits
+    @exhibits
+  end
+
+  # Returns the current Blacklight solr response for results that should be displayed in current browse navigation scope
+  # @return [RSolr::Ext::Response]
+  def browse_response
+    @browse_response
+  end
+
+  # Returns the current document list from Blacklight solr response for results that should be displayed in current browse navigation scope
+  # @return [Array] array of SolrDocument returned by search result
+  def browse_document_list
+    @browse_document_list
+  end
+
+  # Returns the current extra controller params used in the query to Solr for Browsing response results
+  # @return [Hash]
+  def current_extra_controller_params
+    @extra_controller_params
+  end
+
+  # Initialize the collection and browse instance variables for a current collection scope. To initialize
+  # anything it expects params[:id] to the be collection id if the current controller is "atrium_collections".
+  # If it sees params[:collection_id] defined that will be used.  If neither are present then nothing will
+  # be initialized.
+  #   If possibled the following will be initialized:
+  #      @atrium_collection [Atrium::Collection] The collection object
+  #      @browse_levels [Array] The array of Atrium::BrowseLevel objects for this collection
+  #      @browse_response [Solr::Response] The response from solr for current collection browse scope (will include any filters/facets applied by browse)
+  #      @browse_document_list [Array] An array of SolrDocuments for the current browse scope
+  #
+  def __initialize_collection(collection_id)
+
+    unless collection_id
+      logger.error("Could not initialize collection. If controller is 'atrium_collections' than :id must be defined.  Otherwise, :collection_id must be defined.  Params were: #{params.inspect}")
+      return
+    end
+
+    begin
+      @atrium_collection = Atrium::Collection.find(collection_id) if @atrium_collection.nil?
+      #raise "No collection was found with id: #{collection_id}" if @atrium_collection.nil?
+      @exhibits = @atrium_collection.exhibits
+      if params[:exhibit_number]
+        exhibit_index = params[:exhibit_number].to_i
+        @exhibit = @exhibits.fetch(exhibit_index-1) if @exhibits && exhibit_index && exhibit_index <= @exhibits.size
+      elsif params[:exhibit_id]
+        @exhibit = Atrium::Exhibit.find(params[:exhibit_id])
+      end
+      ##logger.debug("Collection: #{@atrium_collection}")
+      @extra_controller_params ||= {}
+      params[:browse_level_id] ? @browse_level = Atrium::BrowseLevel.find(params[:browse_level_id]): @browse_level = get_current_browse_level(@exhibit)
+      @extra_controller_params = prepare_extra_controller_params_for_collection_query(@atrium_collection,@exhibit,@browse_level,params,@extra_controller_params)
+      (@response, @document_list) = get_search_results(params, @extra_controller_params)
+      @images = get_all_children(@document_list, "is_part_of_s")
+      #@members = get_all_children(@document_list, "is_member_of_s")
+      #reset to just filters in collection filter
+      @extra_controller_params = reset_extra_controller_params_after_collection_query(@atrium_collection,@exhibit,@browse_level,@extra_controller_params)
+      @browse_response = @response
+      @browse_document_list = @document_list
+      ##logger.debug("Collection: #{@atrium_collection}, Exhibit: #{@atrium_collection.exhibits}")
+      @collection_showcase = Atrium::Showcase.with_selected_facets(@atrium_collection.id,@atrium_collection.class.name, params[:f]).first
+      ##logger.debug("Collection level showcase: #{@collection_showcase.inspect}")
+    rescue Exception=>e
+      logger.error("Could not initialize collection information for id #{collection_id}. Reason - #{e.to_s}")
+    end
+  end
+
+    # added as part of solr search params to exclude items from search result
+    # as :f, to solr as appropriate :fq query.
+  def add_exclude_fq_to_solr(solr_parameters, user_params)
+    # :fq, map from :f.
+    ##logger.debug("Solr exclude!!!: #{solr_parameters.inspect}, #{user_params.inspect}")
+    if ( user_params[:exclude])
+      exclude_request_params = user_params[:exclude]
+      ##logger.debug("user_params[:exclude]!!!: #{user_params[:exclude].inspect}")
+      solr_parameters[:fq] ||= []
+      exclude_request_params.each_pair do |facet_field, value_list|
+        value_list ||= []
+        value_list = [value_list] unless value_list.respond_to? :each
+        value_list.each do |value|
+          exclude_query="-(#{facet_value_to_fq_string(facet_field, value)})"
+          solr_parameters[:fq] << exclude_query
+          ##logger.debug("Solr exclude!!!: #{exclude_query.inspect},   #{solr_parameters.inspect}, #{user_params.inspect}")
+        end
+      end
+    end
+  end
+
+  def get_current_filter_query_params(collection,exhibit,browse_level)
+    #params[:exclude]={:f=>{"collection_0_did_0_unittitle_0_imprint_0_publisher_facet"=>["Continental Currency"]}}
+    filter_query_params = nil
+    ex_filter_query_params = solr_search_params(collection.filter_query_params) if collection && !collection.filter_query_params.nil?
+    exhibit_filter_query_params = solr_search_params(exhibit.filter_query_params) if exhibit && !exhibit.filter_query_params.nil?
+    bl_filter_query_params = solr_search_params(browse_level.filter_query_params) if browse_level && !browse_level.filter_query_params.nil?
+    bl_exclude_query_params = solr_search_params(browse_level.exclude_query_params) if browse_level && !browse_level.exclude_query_params.nil?
+    ##logger.debug("##### Exclude: #{bl_exclude_query_params.inspect}")
+    queries = []
+    queries << ex_filter_query_params[:q] if (ex_filter_query_params && ex_filter_query_params[:q])
+    queries << exhibit_filter_query_params[:q] if (exhibit_filter_query_params && exhibit_filter_query_params[:q])
+    queries << bl_filter_query_params[:q] if (bl_filter_query_params && bl_filter_query_params[:q])
+    fq = []
+    fq.concat(ex_filter_query_params[:fq]) if (ex_filter_query_params && ex_filter_query_params[:fq])
+    #mixin exhibit facet filters
+    if exhibit_filter_query_params && exhibit_filter_query_params[:fq]
+      exhibit_filter_query_params[:fq].each do |fq_param|
+        fq << fq_param unless fq.include?(fq_param)
+      end
+    end
+    #mixin browse level facet filters
+    if bl_filter_query_params && bl_filter_query_params[:fq]
+      bl_filter_query_params[:fq].each do |fq_param|
+        fq << fq_param unless fq.include?(fq_param)
+      end
+    end
+    if bl_exclude_query_params && bl_exclude_query_params[:fq]
+      bl_exclude_query_params[:fq].each do |fq_exclude_param|
+        fq << fq_exclude_param unless fq.include?(fq_exclude_param)
+      end
+    end
+
+    unless fq.empty? && queries.empty?
+      filter_query_params = {}
+      filter_query_params.merge!(:fq=>fq) unless fq.empty?
+      filter_query_params.merge!(:q=>queries.join(" AND ")) unless queries.empty?
+    end
+    filter_query_params
+  end
+
+  # This method will get extra controller params that are necessary to apply an
+  # collection scope filter.  If there are facets selected in the collection filter and
+  # a menu item is selected it will combine the facet selection from params into
+  # extra controller params to ensure that both are in the query correctly.
+
+  def prepare_extra_controller_params_for_collection_query(collection,exhibit,browse_level,params, extra_controller_params)
+    extra_controller_params ||= {}
+    filter_query_params = get_current_filter_query_params(collection,exhibit,browse_level)
+    queries = []
+    #build_lucene_query will be defined if hydra is present to add hydra rights into query etc, otherwise it will be ignored
+    queries << build_lucene_query(params[:q]) if respond_to?(:build_lucene_query)
+    queries << filter_query_params[:q] if (filter_query_params && filter_query_params[:q])
+    queries << params[:q] if params[:q]
+    queries.empty? ? q = params[:q] : q = queries.join(" AND ")
+    extra_controller_params.merge!(:q=>q) unless q.nil?
+    extra_controller_params.merge!(:fq=>filter_query_params[:fq]) if filter_query_params && filter_query_params[:fq]
+    #merge in user params before doing query to correctly handle facets in both extra controller params and params
+    if (extra_controller_params && extra_controller_params[:fq])
+      session_search_params = solr_search_params(params)
+      if session_search_params[:fq]
+        extra_controller_params[:fq].each do |extra_param|
+          #only add if it is not already in params
+          session_search_params[:fq] << extra_param unless session_search_params[:fq].include?(extra_param)
+        end
+        extra_controller_params.merge!(:fq=>session_search_params[:fq])
+      end
+    end
+    extra_controller_params
+  end
+
+  def reset_extra_controller_params_after_collection_query(collection,exhibit,browse_level,extra_controller_params)
+    extra_controller_params ||= {}
+    filter_query_params = get_current_filter_query_params(collection,exhibit,browse_level)
+    extra_controller_params.merge!(:fq=>filter_query_params[:fq]) if filter_query_params && filter_query_params[:fq]
+    extra_controller_params
+  end
+
+  # Returns an array of Atrium::Exhibit objects with its BrowseLevel objects populated with current display
+  # data.  It is expected that it will be used for generating current navigation controls when browsing an collection.
+  # All possible browse levels will be present but values will only be filled in for levels that should be
+  # in view.  It will fill in values for the top browse level, and then will only fill in values for the second browse level
+  # if something is selected, and so on for any deeper browse levels.  If no label is defined
+  # for a browse level, it will fill in the default label for the browse level facet.
+  # If nothing is selected in the first level, there will be no second element.  This pattern
+  # continues as it maintains the state for a user drilling into the content by expanding and collapses
+  # browse category values at each browse level.  This method calls get_browse_level_data
+  # to actually retrieve the array of data after it makes sure a response for browse information
+  # has come back from Blacklight Solr
+  # @return [Array] An array of Atrium::Exhibit objects defind for an collection with BrowseLevel objects populated with view data
+  # @example Get First Browse Level data
+  #   You would access the first level of the first browse set as follows:
+  #
+  #   top_browse_level = exhibits.first.browse_levels.first
+  #   #get menu values to display
+  #   top_browse_level.values
+  #   #get label for the browse category
+  #   top_browse_level.label
+  #   #check if level has a selected value
+  #   top_browse_level.selected?
+  #
+  #   One should use the above methods to generate data for expand/collapse controls, breadcrumbs, etc.
+  def get_exhibit_navigation_data
+    ##logger.debug("get_exhibit_navigation_data browse response: #{browse_response.inspect}")
+    initialize_collection if atrium_collection.nil?
+    browse_data = []
+    unless atrium_collection.nil? || atrium_collection.exhibits.nil?
+      atrium_collection.exhibits.each do |exhibit|
+        if exhibit.respond_to?(:browse_levels) && !exhibit.browse_levels.nil?
+          updated_browse_levels = get_browse_level_data(atrium_collection,exhibit,exhibit.browse_levels,browse_response,current_extra_controller_params,true)
+          ##logger.debug("Updated Browse Levels: #{updated_browse_levels.inspect}")
+          exhibit.browse_levels.each_index do |index|
+            ##logger.debug("#{exhibit.browse_levels.inspect}")
+            exhibit.browse_levels.fetch(index).values = updated_browse_levels.fetch(index).values
+            exhibit.browse_levels.fetch(index).label = updated_browse_levels.fetch(index).label
+            exhibit.browse_levels.fetch(index).selected = updated_browse_levels.fetch(index).selected
+          end
+          exhibit.browse_levels.flatten!(1)
+          browse_data << exhibit
+        end
+      end
+    end
+    ##logger.debug("Before BrowseData: #{browse_data.inspect}")
+
+    browse_data=[] if check_for_scope(browse_data)
+    @exhibit_navigation_data=browse_data
+
+    ##logger.debug("After BrowseData: #{browse_data.inspect}")
+    browse_data
+  end
+
+  private
+
+  def check_for_scope(exhibit_list)
+    scoped_to_items=false
+    if atrium_collection && atrium_collection.filter_query_params && atrium_collection.filter_query_params[:solr_doc_ids]
+      scoped_to_items=true
+    end
+    return scoped_to_items
+  end
+
+  # This is a private method and should not be called directly.
+  # get_exhibit_navigation_data calls this method to fill out the browse_level_navigation_data array
+  # This method calls itself recursively as it generates the current browse state data.
+  # It returns the browse levels array with its browse level objects passed in updated
+  # with any values, label, and selected value if one is selected.  It will fill in values
+  # for the top browse level, and then will only fill in values for the second browse level
+  # if something is selected, and so on for any deeper browse levels.  If no label is defined
+  # for a browse level, it will fill in the default label for the browse level facet.
+  # @param [Atrium::Collection] The current collection
+  # @param [Atrium::Exhibit] the current exhibit
+  # @params [Array] The current browse levels (will reduce as this method recurses)
+  # @param [SolrResponse] the browse response from solr
+  # @param [Hash] the extra controller params that need to be passed to solr if we query for another response if necessary to get child level data
+  # @param [Boolean] true if the top level of the exhibit
+  # @return [Array] An array of update BrowseLevel objects that are enhanced with current navigation data such as selected, values, and label filled in
+  #   The relevant attributes of a BrowseLevel are
+  #   :solr_facet_name [String] the facet used as the category for that browse level
+  #   :label [String] browse level category label
+  #   :values [Array] values to display for the browse level
+  #   :selected [String] the selected value if one
+  def get_browse_level_data(collection, exhibit, browse_levels, response, extra_controller_params={},top_level=false)
+    exhibit_number = exhibit.set_number
+    updated_browse_levels = []
+    unless browse_levels.nil? || browse_levels.empty?
+      browse_level = browse_levels.first
+      browse_facet_name = browse_level.solr_facet_name
+      browse_level.label = facet_field_labels[browse_facet_name] if (browse_level.label.nil? || browse_level.label.blank?)
+      #always add whether there should be values set or not
+      updated_browse_levels << browse_level
+      if params.has_key?(:f) && !params[:f].nil?
+        temp = params[:f].dup
+        unless top_level && !params[:f][browse_facet_name] && !params[:f][browse_facet_name.to_s]
+          browse_levels.each_with_index do |cur_browse_level,index|
+            params[:f].delete(cur_browse_level.solr_facet_name)
+          end
+        else
+          params[:f] = {}
+        end
+        extra_controller_params = prepare_extra_controller_params_for_collection_query(collection,exhibit,browse_level,params,extra_controller_params)
+        (response_without_f_param, @new_document_list) = get_search_results(params,extra_controller_params)
+        extra_controller_params = reset_extra_controller_params_after_collection_query(collection,exhibit,browse_level,extra_controller_params)
+        params[:f] = temp
+      else
+        extra_controller_params = prepare_extra_controller_params_for_collection_query(collection,exhibit,browse_level,params,extra_controller_params)
+        (response_without_f_param, @new_document_list) = get_search_results(params,extra_controller_params)
+        extra_controller_params = reset_extra_controller_params_after_collection_query(collection,exhibit,browse_level,extra_controller_params)
+      end
+      display_facet = response_without_f_param.facets.detect {|f| f.name == browse_facet_name}
+      display_facet_with_f = response.facets.detect {|f| f.name == browse_facet_name}
+      unless display_facet.nil?
+        level_has_selected = false
+        if display_facet.items.any?
+          display_facet.items.each do |item|
+            if facet_in_params?(display_facet.name, item.value )
+              level_has_selected = true
+              updated_browse_levels.first.selected = item.value
+              if browse_levels.length > 1
+                updated_browse_levels << get_browse_level_data(collection,exhibit,browse_levels.slice(1,browse_levels.length-1), response, extra_controller_params)
+                #make sure to flatten any nested arrays from recursive calls
+                updated_browse_levels.flatten!(1)
+              end
+            end
+            updated_browse_levels.first.values << item.value
+          end
+        end
+        #check if facet_in_params and if not just add rest of levels so all are represented since nothing below will be selected
+        unless level_has_selected
+          updated_browse_levels << browse_levels.slice(1,browse_levels.length-1)
+          updated_browse_levels.flatten!(1)
+        end
+      end
+    end
+    updated_browse_levels
+  end
+
+  def get_atrium_showcase(exhibit_id, facet_hash={})
+    atrium_showcase= Atrium::Showcase.with_selected_facets(exhibit_id,facet_hash)
+    return atrium_showcase
+  end
+
+  # Checks if a browse level has been navigated to for a exhibit
+  # @param [Atrium::Exhibit] The current exhibit in view
+  # @return [Atrium::BrowseLevel] It will return a browse level that is selected, otherwise it will return nil
+  def get_current_browse_level(exhibit)
+    cur_browse_level = nil
+    if exhibit
+      #keep recursing until lowest level that has a facet selected is found
+      exhibit.browse_levels.each do |browse_level|
+        cur_browse_level = browse_level if browse_level.solr_facet_name && facet_selected?(browse_level.solr_facet_name)
+      end
+    end
+    cur_browse_level
+  end
+
+  def facet_selected?(facet_name)
+    params[:f].include?(facet_name) if params[:f]
+  end
+
+  def display_solr_essay(pid)
+    ##logger.debug("description: #{pid.inspect}")
+    response, document = get_solr_response_for_doc_id(pid)
+    content = render_document_show_field_value :document => document, :field => 'description_content_s'
+    ##logger.debug("Content:#{content}")
+    return content.html_safe
+  end
+
+  def get_all_children(doc_list, relationship_field_names, opts={})
+    @child_hash={}
+    parent_arr=[]
+    modified_arr=[]
+    #logger.debug("Get children for list: #{doc_list.count}")
+    doc_list.each_with_index do |doc, i|
+      parent_arr<< doc["id"] unless (doc["id"].blank?)
+    end
+    parent_arr.each do |id|
+      rel_id="info:fedora/#{id}"
+      modified_arr<< rel_id
+    end
+    #logger.debug("Get children for list: #{parent_arr.inspect}, #{modified_arr.inspect}")
+    p = params.dup
+    params.delete(:f)
+    params.delete(:page)
+    params.delete(:q)
+    params.delete(:fq)
+    params.delete(:per_page)
+    params[:rows] = 1000
+    params[:per_page] = 1000
+    response, response_list = get_solr_response_for_field_values(relationship_field_names,modified_arr)   ##get child pages
+    #response, is_member_response_list = get_solr_response_for_field_values("is_member_of_s",modified_arr)        ## get any child components
+    logger.debug("Relationship:#{relationship_field_names.inspect}, Children count:#{response_list.count}")
+    params.delete(:rows)
+    params[:f] = p[:f]
+    params[:page] = p[:page]
+    params[:q] = p[:q]
+    params[:fq] = p[:fq]
+    params[:per_page] = p[:per_page]
+    parent_arr.each do |parent|
+      ##logger.debug("Processing id: #{parent.inspect}")
+      child_arr=[]
+      member_arr=[]
+      response_list.each do |doc|
+        parent_id = doc[relationship_field_names].first.split("/").last
+        if parent_id.eql?(parent)
+          #logger.debug("is_part_response_list parent #{doc[relationship_field_names.to_s].inspect}, id: #{doc["id"].inspect} ")
+          child_arr<<doc
+        end
+      end
+      #is_member_response_list.each do |doc|
+      #  parent_id = doc["is_member_of_s"].first.split("/").last
+      #  if parent_id.eql?(parent)
+      #    ##logger.debug("is_member_of_s_response_list parent #{doc["is_member_of_s"].inspect}, id: #{doc["id"].inspect} ")
+      #    member_arr<<doc
+      #  end
+      #end
+      #@image_hash[parent]=image_arr
+      #@member_hash[parent]=member_arr
+      @child_hash[parent]=child_arr
+    end
+    #return [@image_hash, @member_hash ]
+    return @child_hash
+  end
+end