bento_search 1.7.0.beta.1 → 1.7.0

data/app/models/bento_search/multi_searcher.rb

@@ -1,19 +1,19 @@
-begin 
+begin
   require 'celluloid'
 
   # Based on Celluloid, concurrently runs multiple searches in
   # seperate threads. You must include 'celluloid' gem dependency
   # into your local app to use this class. Requires celluloid 0.12.0
-  # or above (for new preferred async syntax). 
+  # or above (for new preferred async syntax).
   #
   # Warning, if you don't have celluloid in your app, this class simply
   # won't load. TODO: We should put this file in a different directory
   # so it's never auto-loaded, and requires a "require 'bento_search/multi_searcher'",
   # such that it will raise without celluloid only then, and we don't need this
-  # rescue LoadError stuff. 
+  # rescue LoadError stuff.
   #
   # I am not an expert at use of Celluloid, it's possible there's a better
-  # way to do this all, but seems to work. 
+  # way to do this all, but seems to work.
   #
   # ## Usage
   #
@@ -26,14 +26,14 @@ begin
   # retrieve results, blocking until each is completed:
   #     searcher.results
   #
-  # returns a Hash keyed by engine id, values BentoSearch::Results objects. 
+  # returns a Hash keyed by engine id, values BentoSearch::Results objects.
   #
   # Can only call #results once per #start, after that it'll return empty hash.
-  # (should we make it actually raise instead?). . 
-  # 
+  # (should we make it actually raise instead?). .
+  #
   # important to call results at some point after calling start, in order
   # to make sure Celluloid::Actors are properly terminated to avoid
-  # resource leakage. May want to do it in an ensure block. 
+  # resource leakage. May want to do it in an ensure block.
   #
   # Note that celluloid uses multi-threading in such a way that you
   # may have to set config.cache_classes=true even in development
@@ -41,87 +41,88 @@ begin
   #
   #
   # TODO: have a method that returns Futures instead of only supplying the blocking
-  # results method? Several tricks, including making sure to properly terminate actors. 
+  # results method? Several tricks, including making sure to properly terminate actors.
   class BentoSearch::MultiSearcher
-    
+
     def initialize(*engine_ids)
+      ActiveSupport::Deprecation.warn('BentoSearch::MultiSearcher is deprecated and will be removed in bento_search 2.0. Please use BentoSearch::ConcurrentSearcher instead.', caller.slice(1..-1))
+
       @engines = []
       @actors = []
       engine_ids.each do |id|
         add_engine( BentoSearch.get_engine id )
       end
     end
-    
+
     # Adds an instantiated engine directly, rather than by id from global
-    # registry. 
-    def add_engine(engine)    
+    # registry.
+    def add_engine(engine)
       @engines << engine
     end
-    
-    # Starts all searches, returns self so you can chain method calls if you like. 
+
+    # Starts all searches, returns self so you can chain method calls if you like.
     def search(*search_args)
       @engines.each do |engine|
         a = Actor.new(engine)
         @actors << a
         a.async.start *search_args
-      end    
+      end
       return self
     end
     alias_method :start, :search # backwards compat
-    
+
     # Call after #start. Blocks until each included engine is finished
     # then returns a Hash keyed by engine registered id, value is a
-    # BentoSearch::Results object. 
+    # BentoSearch::Results object.
     #
     # Can only call _once_ per invocation of #start, after that it'll return
-    # an empty hash. 
+    # an empty hash.
     def results
       results = {}
-      
+
       # we use #delete_if to get an iterator that deletes
-      # each item after iteration. 
+      # each item after iteration.
       @actors.delete_if do |actor|
         result_key = (actor.engine.configuration.id || actor.engine.class.name)
         results[result_key] = actor.results
         actor.terminate
-        
+
         true
       end
-      
+
       return results
     end
-    
-    
+
+
     class Actor
       include Celluloid
-      
+
       attr_accessor :engine
-      
+
       def initialize(a_engine)
         self.engine = a_engine
       end
-      
-      # call as .async.start, to invoke async. 
+
+      # call as .async.start, to invoke async.
       def start(*search_args)
         begin
           @results = self.engine.search(*search_args)
         rescue StandardError => e
           Rails.logger.error("\nBentoSearch:MultiSearcher caught exception: #{e}\n#{e.backtrace.join("   \n")}")
-          # Make a fake results with caught exception. 
+          # Make a fake results with caught exception.
           @results = BentoSearch::Results.new
           self.engine.fill_in_search_metadata_for(@results, self.engine.normalized_search_arguments(search_args))
-          
+
           @results.error ||= {}
-          @results.error["exception"] = e           
+          @results.error["exception"] = e
         end
       end
-      
+
       def results
         @results
       end
-      
+
     end
-    
   end
 
 rescue LoadError

data/app/models/bento_search/search_engine.rb

@@ -17,7 +17,6 @@ module BentoSearch
   # remote service. Not yet universally used.
   class ::BentoSearch::FetchError < ::BentoSearch::Error ; end
 
-
   # Module mix-in for bento_search search engines.
   #
   # ==Using a SearchEngine
@@ -65,6 +64,11 @@ module BentoSearch
   #      string name, actual class object not supported (to make it easier
   #      to serialize and transport configuration).
   #
+  # [log_failed_results]
+  #       Default false, if true all failed results are logged to
+  #       `Rails.log.error`. Can set global default with
+  #        `BentoSearch.defaults.log_failed_results = true`
+  #
   # == Implementing a SearchEngine
   #
   # Implmeneting a new SearchEngine is relatively straightforward -- you are
@@ -119,15 +123,53 @@ module BentoSearch
   module SearchEngine
     DefaultPerPage = 10
 
-
-
-
     extend ActiveSupport::Concern
 
     include Capabilities
 
+    mattr_accessor :default_auto_rescued_exceptions
+    self.default_auto_rescued_exceptions = [
+        BentoSearch::RubyTimeoutClass,
+        HTTPClient::TimeoutError,
+        HTTPClient::ConfigurationError,
+        HTTPClient::BadResponseError,
+        MultiJson::DecodeError,
+        Nokogiri::SyntaxError,
+        SocketError
+      ].freeze
+
     included do
       attr_accessor :configuration
+
+      # What exceptions should our #search wrapper rescue and turn
+      # into failed results instead of fatal errors?
+      #
+      # Can't rescue everything, or we eat VCR/webmock errors, and lots
+      # of other errors we don't want to eat either, making
+      # development really confusing.  Perhaps could set this
+      # to be something diff in production and dev?
+      #
+      # This default list is probably useful already, but individual
+      # engines can override if it's convenient for their own error
+      # handling.
+      #
+      # Override by just using `auto_rescued_exceptions=` on class _or_ method,
+      # although some legacy code may override `def auto_rescue_exceptions` (note
+      # old `rescue` vs new `rescued`) which should work too.
+      self.class_attribute :auto_rescued_exceptions
+      self.auto_rescued_exceptions = ::BentoSearch::SearchEngine.default_auto_rescued_exceptions
+
+      # Over-ride returning a hash or Confstruct with
+      # any configuration values you want by default.
+      # actual user-specified config values will be deep-merged
+      # into the defaults.
+      def self.default_configuration
+      end
+
+      # Over-ride returning an array of symbols for required
+      # configuration keys.
+      def self.required_configuration
+      end
     end
 
     # If specific SearchEngine calls initialize, you want to call super
@@ -153,6 +195,9 @@ module BentoSearch
 
       # global defaults?
       self.configuration[:for_display] ||= {}
+      unless self.configuration.has_key?(:log_failed_results)
+        self.configuration[:log_failed_results] = BentoSearch.defaults.log_failed_results
+      end
 
       # check for required keys -- have to be present, and not nil
       if self.class.required_configuration
@@ -241,8 +286,11 @@ module BentoSearch
 
       fill_in_search_metadata_for(failed, arguments)
 
-
       return failed
+    ensure
+      if results && configuration.log_failed_results && results.failed?
+        Rails.logger.error("Error fetching results for `#{configuration.id || self}`: #{arguments}: #{results.error}")
+      end
     end
 
     # SOME of the elements of Results to be returned that SearchEngine implementation
@@ -392,9 +440,26 @@ module BentoSearch
       [:query, :search_field, :semantic_search_field, :sort, :page, :start, :per_page]
     end
 
+    # Cover method for consistent api with Results
+    def display_configuration
+      configuration.for_display
+    end
+
+    # Cover method for consistent api with Results
+    def engine_id
+      configuration.id
+    end
+
 
     protected
 
+    # For legacy reasons old name auto_rescue_exceptions is here, some
+    # sub-classes may override it. Now preferred to use auto_rescued_exceptions
+    # setter instead.
+    def auto_rescue_exceptions
+      self.auto_rescued_exceptions
+    end
+
     # get value of an arg that can be supplied in search args OR config,
     # with search_args over-ridding config. Also normalizes value to_s
     # (for symbols/strings).
@@ -409,40 +474,5 @@ module BentoSearch
 
       return value
     end
-
-    # What exceptions should our #search wrapper rescue and turn
-    # into failed results instead of fatal errors?
-    #
-    # Can't rescue everything, or we eat VCR/webmock errors, and lots
-    # of other errors we don't want to eat either, making
-    # development really confusing.  Perhaps could set this
-    # to be something diff in production and dev?
-    #
-    # This default list is probably useful already, but individual
-    # engines can override if it's convenient for their own error
-    # handling.
-    def auto_rescue_exceptions
-      [BentoSearch::RubyTimeoutClass, HTTPClient::TimeoutError,
-            HTTPClient::ConfigurationError, HTTPClient::BadResponseError,
-            MultiJson::DecodeError, Nokogiri::SyntaxError, SocketError]
-    end
-
-
-    module ClassMethods
-
-      # Over-ride returning a hash or Confstruct with
-      # any configuration values you want by default.
-      # actual user-specified config values will be deep-merged
-      # into the defaults.
-      def default_configuration
-      end
-
-      # Over-ride returning an array of symbols for required
-      # configuration keys.
-      def required_configuration
-      end
-
-    end
-
   end
 end

data/app/search_engines/bento_search/doaj_articles_engine.rb

@@ -16,7 +16,7 @@ module BentoSearch
     include ActionView::Helpers::SanitizeHelper
 
 
-    class_attribute :http_timeout
+    class_attribute :http_timeout, instance_writer: false
     self.http_timeout = 10
 
     extend HTTPClientPatch::IncludeClient

data/app/search_engines/bento_search/eds_engine.rb

@@ -25,45 +25,40 @@ require 'http_client_patch/include_client'
 # == Linking
 #
 # The link to record in EBSCO interface delivered as "PLink" will be listed
-# as record main link.
+# as record main link. If the record includes a node at `./FullText/Links/Link/Type[text() = 'pdflink']`,
+# the `plink` will be marked as fulltext. (There may be other cases of fulltext, but
+# this seems to be all EDS API tells us.)
 #
 # Any links listed under <CustomLinks> will be listed as other_links, using
-# configured name provided by EBSCO for CustomLink.
+# configured name provided by EBSCO for CustomLink. Same with links listed
+# as `<Item><Group>URL</Group>`.
 #
-# EDS Response does not have sufficient metadata for us to generate an OpenURL
-# ourselves. However, in our testing, the first/only CustomLink was an
-# an OpenURL. If configuration.assume_first_custom_link_openurl is
-# true (as is default), it will be used to create an OpenURL link. However, in
-# our testing, many records don't have this at all. **Note** You want
-# to configure your profile so OpenURLs are ALWAYS included for all records, not
-# just records with no EBSCO fulltext, to ensure bento_search can get the
-# openurl. http://support.ebsco.com/knowledge_base/detail.php?id=1111 (May
-# have to ask EBSCO support for help, it's confusing!).
+# As always, you can customize links and other_links with Item Decorators.
 #
-# TODO: May have to add configuration code to pull the OpenURL link out by
-# it's configured name or label, not assume first one is it.
+# == Custom Data
 #
-# As always, you can customize links and other_links with Item Decorators.
+# If present, there is a custom_data[:holdings] value, an array of
+# BentoSearch::EdsEngine::Holding objects, each of which has a #location
+# and #call_number. There will usually (always?) be at most 1 item in the
+# array, as far as we can tell from how EDS works.
 #
 # == Technical Notes and Difficulties
 #
-# This API is enormously difficult to work with. Also the response is very odd
-# to deal with and missing some key elements. We quite possibly got something
-# wrong or non-optimal in this implementation, but we did our best.
+# This API is pretty difficult to work with, and the response has many
+# idiosyncratic undocumented parts.  We think we are currently
+# getting fairly complete citation detail out, at least for articles, but may be missing
+# some on weird edge cases, books/book chapters, etc)
 #
 # Auth issues may make this slow -- you need to spend a (not too speedy) HTTP
 # request making a session for every new end-user -- as we have no way to keep
 # track of end-users, we do it on every request in this implementation.
 #
-# Responses don't include much metadata -- we don't actually have journal title,
-# volume, issue, etc.  We probably _could_ parse it out of the OpenURL that's
-# there depending on your profile configuration, but we're not right now.
-# Instead we're using the chunk of user-displayable citation/reference it does
-# give us (which is very difficult to parse into something usable already),
-# and a custom Decorator to display that instead of normalized citation
-# made from individual elements.
-#
-# EBSCO says they plan to improve some of these issues in a September 2012 release.
+# An older version of the EDS API returned much less info, and we tried
+# to scrape out what we could anyway. Much of this logic is still there
+# as backup. In the older version, not enough info was there for an
+# OpenURL link, `configuration.assume_first_custom_link_openurl` was true
+# by default, and used to create an OpenURL link. It now defaults to false,
+# and should no longer be neccessary.
 #
 # Title and abstract data seems to be HTML with tags and character entities and
 # escaped special chars. We're trusting it and passing it on as html_safe.
@@ -91,7 +86,7 @@ require 'http_client_patch/include_client'
 #
 # == EDS docs:
 #
-# * Console App to demo requests: https://eds-api.ebscohost.com/Console
+# * Console App to demo requests: <
 # * EDS Wiki: http://edswiki.ebscohost.com/EDS_API_Documentation
 # * You'll need to request an account to the EDS wiki, see: http://support.ebsco.com/knowledge_base/detail.php?id=5990
 #
@@ -101,11 +96,20 @@ class BentoSearch::EdsEngine
 
   # Can't change http timeout in config, because we keep an http
   # client at class-wide level, and config is not class-wide.
-  # Change this 'constant' if you want to change it, I guess.
+  # We used to keep in constant, but that's not good for custom setting,
+  # we now use class_attribute, but in a weird backwards-compat way for
+  # anyone who might be using the constant.
   HttpTimeout = 4
+
+  class_attribute :http_timeout, instance_writer: false
+  def self.http_timeout
+    defined?(@http_timeout) ? @http_timeout : HttpTimeout
+  end
+
+
   extend HTTPClientPatch::IncludeClient
   include_http_client do |client|
-    client.connect_timeout = client.send_timeout = client.receive_timeout = HttpTimeout
+    client.connect_timeout = client.send_timeout = client.receive_timeout = http_timeout
   end
 
   AuthHeader          = "x-authenticationToken"
@@ -131,12 +135,7 @@ class BentoSearch::EdsEngine
   # an object that includes some Rails helper modules for
   # text handling.
   def helper
-    unless @helper ||= nil
-      @helper = Object.new
-      @helper.extend ActionView::Helpers::TextHelper # for truncate
-      @helper.extend ActionView::Helpers::OutputSafetyHelper # for safe_join
-    end
-    return @helper
+    @helper ||= Helper.new
   end
 
 
@@ -207,8 +206,6 @@ class BentoSearch::EdsEngine
 
         url = construct_search_url(args)
 
-
-
         response = get_with_auth(url, session_token)
 
         results = BentoSearch::Results.new
@@ -237,39 +234,96 @@ class BentoSearch::EdsEngine
 
           item.abstract = prepare_eds_payload( element_by_group(record_xml, "Ab"), true )
 
-          # Believe it or not, the authors are encoded as an escaped
-          # XML-ish payload, that we need to parse again and get the
-          # actual authors out of. WTF. Thanks for handling fragments
-          # nokogiri.
-          author_mess = element_by_group(record_xml, "Au")
-          # only SOMETIMES does it have XML tags, other times it's straight text.
-          # ARGH.
-          author_xml = Nokogiri::XML::fragment(author_mess)
-          searchLinks = author_xml.xpath(".//searchLink")
-          if searchLinks.size > 0
-            author_xml.xpath(".//searchLink").each do |author_node|
-              item.authors << BentoSearch::Author.new(:display => author_node.text)
+          # Much better way to get authors out of EDS response now...
+          author_full_names = record_xml.xpath("./RecordInfo/BibRecord/BibRelationships/HasContributorRelationships/HasContributor/PersonEntity/Name/NameFull")
+          author_full_names.each do |name_full_xml|
+            if name_full_xml && (text = name_full_xml.text).present?
+              item.authors << BentoSearch::Author.new(:display => text)
             end
-          else
-            item.authors << BentoSearch::Author.new(:display => author_xml.text)
           end
 
+          if item.authors.blank?
+            # Believe it or not, the authors are encoded as an escaped
+            # XML-ish payload, that we need to parse again and get the
+            # actual authors out of. WTF. Thanks for handling fragments
+            # nokogiri.
+            author_mess = element_by_group(record_xml, "Au")
+            # only SOMETIMES does it have XML tags, other times it's straight text.
+            # ARGH.
+            author_xml = Nokogiri::XML::fragment(author_mess)
+            searchLinks = author_xml.xpath(".//searchLink")
+            if searchLinks.size > 0
+              author_xml.xpath(".//searchLink").each do |author_node|
+                item.authors << BentoSearch::Author.new(:display => author_node.text)
+              end
+            else
+              item.authors << BentoSearch::Author.new(:display => author_xml.text)
+            end
+          end
 
           # PLink is main inward facing EBSCO link, put it as
           # main link.
           if direct_link = record_xml.at_xpath("./PLink")
-              item.link = direct_link.text
+            item.link = direct_link.text
+
+            if record_xml.at_xpath("./FullText/Links/Link/Type[text() = 'pdflink']")
+              item.link_is_fulltext = true
+            end
           end
 
+
           # Other links may be found in CustomLinks, it seems like usually
           # there will be at least one, hopefully the first one is the OpenURL?
-          record_xml.xpath("./CustomLinks/CustomLink").each do |custom_link|
+          #byebug if configuration.id == "articles"
+          record_xml.xpath("./CustomLinks/CustomLink|./FullText/CustomLinks/CustomLink").each do |custom_link|
+            # If it's in FullText section, give it a rel=alternate
+            # to indicate it's fulltext
+            rel = (custom_link.parent.parent.name.downcase == "fulltext") ? "alternate" : nil
+
             item.other_links << BentoSearch::Link.new(
               :url => custom_link.at_xpath("./Url").text,
-              :label => custom_link.at_xpath("./Name").text
+              :rel => rel,
+              :label => custom_link.at_xpath("./Text").try(:text).presence || custom_link.at_xpath("./Name").try(:text).presence || "Link"
               )
           end
 
+          # More other links in 'URL' Item, in unpredictable format sometimes being
+          # embedded XML. Really EBSCO?
+          record_xml.xpath("./Items/Item[child::Group[text()='URL']]").each do |url_item|
+            data_element = url_item.at_xpath("./Data")
+            next unless data_element
+
+            # SOMETIMES the url and label are in an embedded escaped XML element...
+            if data_element.text.strip.start_with?("<link")
+              # Ugh, once unescpaed it has bare '&' in URL queries sometimes, which
+              # is not actually legal XML anymore, but Nokogiri::HTML parser will
+              # let us get away with it, but then doesn't put the actual text
+              # inside the 'link' item, but inside the <link> tag since it knows
+              # an HTML link tag has no content. Really EDS.
+              node = Nokogiri::HTML::fragment(data_element.text)
+              next unless link = node.at_xpath("./link")
+              next unless link["linkterm"].presence || link["linkTerm"].presence
+
+              item.other_links << BentoSearch::Link.new(
+                :url => link["linkterm"] || link["linkTerm"],
+                :label => helper.strip_tags(data_element.text).presence || "Link"
+                )
+            else
+              # it's just a straight URL in data element, with only label we've
+              # got in <label> element.
+              next unless data_element.text.strip.present?
+
+              label_element = url_item.at_xpath("./Label")
+              label = label_element.try(:text).try { |s| helper.strip_tags(s) }.presence || "Link"
+
+              item.other_links << BentoSearch::Link.new(
+                :url => data_element.text,
+                :label => label
+              )
+            end
+          end
+
+
           if (configuration.assume_first_custom_link_openurl &&
             (first = record_xml.xpath "./CustomLinks/CustomLink" ) &&
             (node = first.at_xpath "./Url" )
@@ -286,7 +340,58 @@ class BentoSearch::EdsEngine
           # Can't find a list of possible PubTypes to see what's there to try
           # and map to our internal controlled vocab. oh wells.
 
+          item.doi = at_xpath_text record_xml, "./RecordInfo/BibRecord/BibEntity/Identifiers/Identifier[child::Type[text()='doi']]/Value"
 
+          item.start_page = at_xpath_text(record_xml, "./RecordInfo/BibRecord/BibEntity/PhysicalDescription/Pagination/StartPage")
+          total_pages = at_xpath_text(record_xml, "./RecordInfo/BibRecord/BibEntity/PhysicalDescription/Pagination/PageCount")
+          if total_pages.to_i != 0 && item.start_page.to_i != 0
+            item.end_page = (item.start_page.to_i + total_pages.to_i - 1).to_s
+          end
+
+
+          # location/call number, probably only for catalog results. We only see one
+          # in actual data, but XML structure allows multiple, so we'll store it as multiple.
+          copy_informations = record_xml.xpath("./Holdings/Holding/HoldingSimple/CopyInformationList/CopyInformation")
+          if copy_informations.present?
+            item.custom_data[:holdings] =
+              copy_informations.collect do |copy_information|
+                Holding.new(:location => at_xpath_text(copy_information, "Sublocation"),
+                            :call_number => at_xpath_text(copy_information, "ShelfLocator"))
+              end
+          end
+
+
+
+          # For some EDS results, we have actual citation information,
+          # for some we don't.
+          container_xml = record_xml.at_xpath("./RecordInfo/BibRecord/BibRelationships/IsPartOfRelationships/IsPartOf/BibEntity")
+          if container_xml
+            item.source_title = at_xpath_text(container_xml, "./Titles/Title[child::Type[text()='main']]/TitleFull")
+            item.volume = at_xpath_text(container_xml, "./Numbering/Number[child::Type[text()='volume']]/Value")
+            item.issue = at_xpath_text(container_xml, "./Numbering/Number[child::Type[text()='issue']]/Value")
+
+            item.issn = at_xpath_text(container_xml, "./Identifiers/Identifier[child::Type[text()='issn-print']]/Value")
+
+            if date_xml = container_xml.at_xpath("./Dates/Date")
+              item.year = at_xpath_text(date_xml, "./Y")
+
+              date = at_xpath_text(date_xml, "./D").to_i
+              month = at_xpath_text(date_xml, "./M").to_i
+              if item.year.to_i != 0 && date != 0 && month != 0
+                item.publication_date = Date.new(item.year.to_i, month, date)
+              end
+            end
+          end
+
+          # EDS annoyingly repeats a monographic title in the same place
+          # we look for source/container title, take it away.
+          if item.start_page.blank? && helper.strip_tags(item.title) == item.source_title
+            item.source_title = nil
+          end
+
+          # Legacy EDS citation extracting. We don't really need this any more
+          # because EDS api has improved, but leave it in in case anyone using
+          # older versions needed it.
 
           # We have a single blob of human-readable citation, that's also
           # littered with XML-ish tags we need to deal with. We'll save
@@ -306,7 +411,6 @@ class BentoSearch::EdsEngine
             item.custom_data["citation_blob"] = element_by_group(record_xml, "SrcInfo")
           end
 
-
           item.extend CitationMessDecorator
 
           results << item
@@ -509,7 +613,7 @@ class BentoSearch::EdsEngine
       :base_url => "http://eds-api.ebscohost.com/edsapi/rest/",
       :highlighting => true,
       :truncate_highlighted => 280,
-      :assume_first_custom_link_openurl => true,
+      :assume_first_custom_link_openurl => false,
       :search_mode => 'all' # any | bool | all | smart ; http://support.epnet.com/knowledge_base/detail.php?topic=996&id=1288&page=1
     }
   end
@@ -559,4 +663,20 @@ class BentoSearch::EdsEngine
     end
   end
 
+  # a class that includes some Rails helper modules for
+  # text handling.
+  class Helper
+    include ActionView::Helpers::SanitizeHelper # for strip_tags
+    include ActionView::Helpers::TextHelper # for truncate
+    include ActionView::Helpers::OutputSafetyHelper # for safe_join
+  end
+
+  class Holding
+    attr_reader :location, :call_number
+    def initialize(args)
+      @location = args[:location]
+      @call_number = args[:call_number]
+    end
+  end
+
 end