umlaut_borrow_direct 1.0.0.pre2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZjlkY2Y1ODU0Zjg0MWNlZWY2MjUzNTFhZmU5ODgyM2QwZDYyYTg1NQ==
+  data.tar.gz: !binary |-
+    NWFlZDVkNTRhMmZhYTI4YmY0NWRhZWViY2EyYmE3YjU0MWE3ZTNhNw==
+SHA512:
+  metadata.gz: !binary |-
+    ZjNlYzhlMWFkYWViZTAwOTkzNGFlOWFhOGY1ZmE4OTBjMGY3OTQ5YmY5OWIy
+    MGU2OGE2YTg1ZTZlN2MyZmExMGQxNzZkZDI1NWZiMmRlNDc4ZTBjY2U0YTlk
+    NzFkYzk5ODEwOGNkYTE0NzQ2ZTRkZTUyNDcxNWUyYzZjNDJlNWQ=
+  data.tar.gz: !binary |-
+    NjQyZmM5ZmE5NjM0ODBhYjVmNTIwNTgwYjBlMGE1OWU0OTIyZWM3ODZkMjQz
+    ZTM1MzQyMmQ2MTZjYTFjMWY2MjYyOTUxMWRjNTgzY2E3ZmZjMDAwN2NhODBm
+    M2UyZWM1YmMyNGMyYjg5MTVjMDM2MGU4ZGUzY2MzNWVhY2FkZGY=

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'UmlautBorrowDirect'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/controllers/borrow_direct_controller.rb

@@ -0,0 +1,6 @@
+# This blank class is a placeholder. It should be implemented in local
+# application, with an override of #current_user_barcode that provides
+# barcode for logged in user, to place request with. 
+class BorrowDirectController < UmlautBorrowDirect::ControllerImplementation
+  
+end

data/app/controllers/umlaut_borrow_direct/controller_implementation.rb

@@ -0,0 +1,208 @@
+require 'uri'
+require 'umlaut_borrow_direct/url_whitelister'
+
+# Superclass for actual BorrowDirectController, which will usually
+# be implemented in local app, with an override of #current_user_barcode
+# that provides some local auth system to figure out current barcode
+# to make a request with. 
+module UmlautBorrowDirect
+  class ControllerImplementation < UmlautController
+    before_filter :load_service_and_response
+
+    # Status codes used in ServiceResponses of type bd_request_status
+    Successful       = "successful"
+    InProgress      = "in_progress"
+    ValidationError = "validation_error" # user input error
+    Error           = "error" # system error
+
+    # Will http GET to here as /borrow_direct/:service_id/:request_id
+    # (really should be POST, but Shibboleth and other SSO protection
+    # have a problem with that, bah. The fact that we are immediately redirecting
+    # should keep it from being as big a deal.)
+    #
+    # Will return a 500 if service_id or service_response_id can't be found
+    def submit_request    
+      # mark the DispatchedService as InProgress again -- we do this
+      # mainly so standard Umlaut will catch if it times out with no
+      # request confirmation update, and mark it as errored appropriately. 
+      @request.dispatched(@service, DispatchedService::InProgress)
+
+      # add a bd_request_status object as a place to mark that we are in progress
+      # specifically with placing a request, and blanking out any previous
+      # errors from existing one. 
+      set_status_response(
+        :status => InProgress,
+        :error_user_message => ""
+      )
+
+      # We need to have a barcode to make a request. Custom sub-class must
+      # supply. 
+
+      # We're gonna kick off the actual request submission in a bg thread,
+      # cause it's so damn slow. Yeah, if the process dies in the middle, we might
+      # lose it. Umlaut will notice after a timeout and display error. 
+      # Saving the @bg_thread only so in testing we can wait on it. 
+      @bg_thread = Thread.new(@request, @service, @request.referent.isbn) do |request, service, isbn|
+        begin
+
+          requester = BorrowDirect::RequestItem.new(self.patron_barcode, service.library_symbol)
+          requester.timeout = @service.http_timeout
+          request_number = requester.make_request!(params[:pickup_location], :isbn => isbn)
+
+          ActiveRecord::Base.connection_pool.with_connection do
+            service.bd_api_log(isbn, "RequestItem", "SUCCESS", requester.last_request_time)
+
+            request.dispatched(service, DispatchedService::Successful)
+            set_status_response({:status => Successful, :request_number => request_number }, request)
+          end
+
+        rescue StandardError => e          
+          ActiveRecord::Base.connection_pool.with_connection do
+            Rails.logger.error("BorrowDirect: Error placing request:  #{e.class} #{e.message}. Backtrace:\n  #{Umlaut::Util.clean_backtrace(e).join("\n  ")}\n")
+
+            request.dispatched(service, DispatchedService::FailedFatal, e)
+
+            status_response_data = {:status => Error}
+            status_response_data[:error_user_message] = e.message if e.kind_of? UserReportableError
+
+            set_status_response(status_response_data, request)
+
+            if service
+              service.bd_api_log(isbn, "RequestItem", e, requester.last_request_time)
+            end
+
+
+            # In testing, we kinda wanna re-raise this guy
+            raise e if defined?(VCR::Errors::UnhandledHTTPRequestError) && e.kind_of?(VCR::Errors::UnhandledHTTPRequestError)
+          end
+        end
+      end
+
+      redirect_back_to_source
+    end
+
+    protected
+
+    # Loads things from ID's giving in params, AND makes sure
+    # all pre-reqs are made for actually submitting the request, and
+    # returns and records an error if not. 
+    def load_service_and_response
+      @service_id = params[:service_id]
+
+      begin
+        @service = ServiceStore.instantiate_service!(@service_id, nil) if @service_id
+      rescue ServiceStore::NoSuchService => e
+      end
+
+      if @service.nil?
+        register_error "No such service for id `#{params[:service_id]}`"
+        return
+      end
+
+      @request = Request.where(:id => params[:request_id]).first
+      if @request.nil?
+        register_error "No Request with id `#{params[:request_id]}`"
+        return
+      end
+
+      if params[:pickup_location].blank?
+        register_error I18n.t("umlaut.services.borrow_direct_adaptor.bd_request_prompt.pickup_validation"), ValidationError
+        return
+      end
+
+      # Okay, we insist on there being an existing bd_request_prompt ServiceResponse,
+      # and on the pickup location matching one of it's pickup locations. BD
+      # itself does no validation of pickup_location (unclear what happens when you send
+      # a bad pickup location), so we've got to be as careful as we can be. 
+      request_prompt = @request.service_responses.to_a.find do |sr|
+        sr.service_id == @service_id &&
+        sr.service_type_value_name == "bd_request_prompt"
+      end
+      if request_prompt.nil?
+        register_error "No existing bd_request_prompt response found for request #{@request.id}"
+        return
+      end
+      unless request_prompt.view_data["pickup_locations"].include? params[:pickup_location]
+        register_error "Pickup location `#{params[:pickup_location]}` not listed as acceptable in bd_request_prompt ServiceResponse #{request_prompt.id}"
+        return
+      end
+    end
+
+    # Redirects back to Umlaut menu, or to redirect URL if given and whitelisted,
+    # or in some cases displays a bad error for whitelist error. 
+    def redirect_back_to_source
+      # If we've been requested to do so, redirect back to an external whitelisted service
+      if (redirect_url = params["redirect"]) && redirect_url.present?
+        if UmlautBorrowDirect::UrlWhitelister.new(self.umlaut_config.lookup!("borrow_direct.redirect_whitelist", [])).whitelisted?(redirect_url)
+          redirect_to redirect_url
+          return
+        else
+          # We used to redirect to plain umlaut page on URL unallowed by whitelist,
+          # but that made debugging a confusing situation even harder. Just error
+          # message it. 
+          error_msg = "Error: UmlautBorrowDirect Controller: Ignoring redirect URL which does not match whitelist: #{redirect_url}"
+          logger.warn(error_msg)
+          render :status => 403, :text => error_msg
+          return
+        end
+      end
+
+      # redirect back to /resolve menu, for same object, add explicit request_id
+      # in too. 
+      redirect_to_resolve_menu
+    end
+
+    # error_type defaults to Error, but can also be ValidationError
+    def register_error(msg, error_type = Error)
+      if error_type == Error
+        Rails.logger.error("BorrowDirectController: #{msg}")
+      end
+
+      if @request && @service
+        set_status_response(
+          :status => error_type,
+          :error_user_message => msg
+        )
+      end
+
+      # Redirect back to menu page
+      if @request
+        redirect_back_to_source
+      else
+        render :status => 400, :text => msg
+      end
+    end
+
+    def set_status_response(properties, request = @request)
+      # do we already have one, or should we create a new one?
+      if bd_status = @request.get_service_type(:bd_request_status).first
+        bd_status.take_key_values(properties)
+        bd_status.save!
+      else
+        properties = properties.merge(
+          :service            => @service,
+          :service_type_value => :bd_request_status
+        )  
+        @request.add_service_response(properties)
+      end
+
+    end
+
+    
+
+    def redirect_to_resolve_menu
+      redirect_to url_for_with_co({:controller => "resolve", "umlaut.request_id" => @request.id}, @request.to_context_object), :status => 303
+    end
+
+    # Should be overridden locally
+    def patron_barcode
+      raise StandardError.new("Developers must override patron_barcode locally to return authorized patron barcode.")
+    end
+
+    # Raise one of these with a message that should be shown to the user,
+    # if you want an error message shown to the user. 
+    class UserReportableError < StandardError ; end
+
+
+  end
+end

data/app/helpers/borrow_direct_presenter.rb

@@ -0,0 +1,124 @@
+# Rails helpers make it hard to isolate things, we wrap up the helpers
+# for our BD resolve section in this helper presenter class. 
+#
+# Where `renderer' is the SectionRenderer object probably available in
+# view as 'renderer'
+# bd_presenter = BorrowDirectPresenter.new(renderer)
+class BorrowDirectPresenter
+  attr_reader :request, :responses, :renderer
+  def initialize(renderer)
+    @renderer = renderer
+    @request = renderer.request
+    @responses = renderer.responses_list
+  end
+
+  # nil or a ServiceResponse with type bd_request_status
+  def status_response
+    unless defined? @status_response
+      @status_response = responses.find {|r| r.service_type_value_name == "bd_request_status"}
+    end
+    return @status_response
+  end
+
+  # nil or a ServiceResponse of type bd_request_prompt
+  def request_prompt_response
+    unless defined? @request_prompt_response
+      @request_prompt_response = responses.find {|r| r.service_type_value_name == "bd_request_prompt"}
+    end
+    return @request_prompt_response
+  end
+
+  # nil or a ServiceResponse of type bd_link_to_search
+  def link_response
+    unless defined? @link_response
+      @link_response = responses.find {|r| r.service_type_value_name == "bd_link_to_search"  }
+    end
+    return @link_response
+  end
+
+  # nil or a ServiceResponse of type bd_not_available
+  def not_available_response
+    unless defined? @not_available_response
+      @not_available_response = responses.find {|r| r.service_type_value_name == "bd_not_available" }
+    end
+    return @not_available_response
+  end
+
+  def request_submission_in_progress?
+    self.status_response && (self.status_response.view_data[:status] == BorrowDirectController::InProgress)
+  end
+
+  def service_in_progress?
+    request.service_types_in_progress?(renderer.service_type_values)
+  end
+
+  # use our custom in progress messages, for checking API, vs placing request.
+  def spinner_render_hash
+    render_hash = renderer.spinner_render_hash
+    if self.request_submission_in_progress?
+      render_hash[:locals][:progress_message] = I18n.t("umlaut.services.borrow_direct_adaptor.bd_request_status.progress") 
+    else
+      render_hash[:locals][:progress_message] = I18n.t("umlaut.services.borrow_direct_adaptor.bd_request_prompt.progress") 
+    end        
+    return render_hash
+  end
+
+  # We show the form if we have one, and we don't have a bd_request_status with 
+  # InProgress or Success
+  def show_request_form?    
+    # have a request form, and do not have a status_response with a normal
+    # code.  We show the form if validation error so they can try again. 
+    # We do NOT show the form if submission error, it was too much stuff on screen,
+    # too confusing. 
+    self.request_prompt_response && (! self.could_not_place_request?) &&
+    ! (  
+        self.status_response && [BorrowDirectController::InProgress, BorrowDirectController::Successful].include?(self.status_response.view_data[:status])
+      )
+  end
+
+  def show_not_available?
+    (! self.status_response) && (! show_request_form? ) && self.not_available_response
+  end
+
+  def show_link_response?
+    self.link_response && (! self.show_confirmation?) && (! self.show_request_form?)
+  end
+
+  def could_not_place_request?
+    self.status_response && self.status_response.view_data[:status] == BorrowDirectController::Error
+  end
+
+  def show_confirmation?
+    self.status_response && self.status_response.view_data[:status] == BorrowDirectController::Successful
+  end
+
+  # nil or a string
+  def validation_error
+    self.status_response && 
+    self.status_response.view_data[:status] == BorrowDirectController::ValidationError &&
+    self.status_response.view_data[:error_user_message]  
+  end
+
+  def user_reportable_error
+    self.status_response &&
+    self.status_response.view_data[:status] == BorrowDirectController::Error &&
+    self.status_response.view_data[:error_user_message]
+  end
+
+  def error_div_classes
+    classes = ["borrow-direct-error"]
+    if self.could_not_place_request?
+      classes.concat ["alert", "alert-danger"]
+    end
+    return classes
+  end
+
+  def error_message_i18n_key
+    if self.could_not_place_request?
+      'umlaut.services.borrow_direct_adaptor.bd_request_status.error'
+    else
+      'umlaut.display_sections.borrow_direct.error'
+    end
+  end
+
+end

data/app/service_adaptors/borrow_direct_adaptor.rb

@@ -0,0 +1,163 @@
+require 'borrow_direct'
+
+# optional parameter http_timeout, in seconds, for HTTP with BD. BD can be _slow_. 
+# default to 20 seconds. Much longer, you might start running into Umlaut's
+# own global request processing timeouts. If timeout is reached, service
+# should produce a URL linking into a DIY BD search, AND display an error. 
+class BorrowDirectAdaptor < Service
+  include MetadataHelper
+
+  required_config_params :library_symbol, :find_item_patron_barcode, :html_query_base_url
+
+  attr_accessor :library_symbol, :http_timeout, :use_bd_api
+
+  def initialize(config)
+    # testing shows truncating titles to 5 words results in fewer
+    # false negatives seemingly without significant false positives. 
+    # but you can set to nil/empty to disable truncation, or
+    # set to a different number. 
+    @limit_title_words = 5 
+    @display_name = "BorrowDirect"
+    @http_timeout = 20
+
+    # Log BD API calls to logger -- defaults to Rails.logger
+    @bd_api_logger = Rails.logger
+
+    # set to 'warn', 'info', 'debug', etc to turn on logging
+    # of succesful FindItem api requests. Useful for looking at error rate. 
+    # nil means don't log. 
+    @bd_api_logger_level = nil
+    # Abort for these rfr_id's -- keep from searching BD when
+    # we came from BD. 
+    @suppress_rfr_ids = ["info:sid/BD"]
+
+    # Should we use the api at all? Set to false to disable API
+    # entirely, because you think it performs too crappily or
+    # because it's not yet avail in production. 
+    @use_bd_api = true
+
+    super
+  end
+
+  def service_types_generated
+    return [ServiceTypeValue[:bd_link_to_search], ServiceTypeValue[:bd_request_prompt], ServiceTypeValue[:bd_not_available], ServiceTypeValue[:bd_request_status]]
+  end
+
+  def appropriate_citation_type?(request)
+    return ! title_is_serial?(request.referent)
+  end
+
+  def handle(request)
+    if request.referrer_id && @suppress_rfr_ids.include?(request.referrer_id)
+      return request.dispatched(self, true)
+    end
+
+    if ! appropriate_citation_type?(request)
+      # we do nothing if it looks like an article or journal title. 
+      return request.dispatched(self, true)
+    end
+
+    if locally_available?(request)
+      # We do nothing if it looks like it's locally available
+      return request.dispatched(self, true)
+    end
+
+    # Always add a manual link to search results
+    make_link_to_search_response(request)
+
+    if can_precheck_borrow_direct?(request)
+      # pre-check it with BD api, this will take a while
+      begin
+        finditem = BorrowDirect::FindItem.new(@find_item_patron_barcode, @library_symbol)
+        finditem.timeout = @http_timeout
+        response = finditem.find(:isbn => request.referent.isbn)
+
+        # Log success if configured, used for looking at error rate
+        bd_api_log(request.referent.isbn, "FindItem", "SUCCESS", finditem.last_request_time)
+
+        if response.requestable?
+          # Mark it requestable!
+          request.add_service_response( 
+            :service=>self, 
+            :display_text => "Choose your delivery location",
+            :display_text_i18n => "bd_request_prompt.display_text",
+            :service_type_value => :bd_request_prompt,
+            :pickup_locations => response.pickup_locations)
+        else
+          request.add_service_response( 
+            :service=>self, 
+            :display_text => "This item is not currently available from BorrowDirect",
+            :display_text_i18n => "bd_not_available.display_text", 
+            :service_type_value => :bd_not_available)
+        end
+      rescue BorrowDirect::Error => e 
+        # BD didn't let us check availability, log it and give them
+        # a consolation direct link response
+        msg =  "BorrowDirect returned error on FindItem, resorting to a bd_link_to_search response instead.\n"
+        msg += "    * Returned error: #{e.inspect}\n"
+        msg += "    * BD url: #{finditem.last_request_uri}\n"
+        msg += "    * Posted with json payload: #{finditem.last_request_json}\n"
+        Rails.logger.error(msg)
+
+        # Special BD error log if configured
+        bd_api_log(request.referent.isbn, "FindItem", e, finditem.last_request_time)
+
+        # And mark it as an error so error message will be displayed. Let's
+        # mark it a temporary error, so it'll be tried again later, it might
+        # be a temporary problem on BD, esp timeout.         
+        return request.dispatched(self, DispatchedService::FailedTemporary, e)
+      end
+    end
+
+    return request.dispatched(self, true)
+  end
+
+  # Does Umlaut have info to think the item is locally available?
+  # By default, check for Umlaut holding responses, but can
+  # be customized with config. 
+  def locally_available?(request)
+    UmlautBorrowDirect.locally_available? request
+  end
+
+  # Right now, if and only if we have an ISBN and the API is enabled. 
+  def can_precheck_borrow_direct?(request)
+    return false unless @use_bd_api
+
+    request.referent.isbn.present?
+  end
+
+  def bd_api_log(isbn, action, result, timing)
+    if result.kind_of? Exception
+      result = "#{result.class}/#{result.message}"
+    end
+
+    if @bd_api_log_level
+      @bd_api_logger.send(@bd_api_log_level, "BD API log\t#{action}\t#{result}\t#{timing.round(1) if timing}\tisbn=#{isbn}")
+    end
+  end
+
+  def make_link_to_search_response(request)
+    # We used to try and include ISBN in our query too, as (ISBN OR (author AND title))
+    # But some BD z3950 endpoints can't handle this query (harvard apparently), and
+    # it's just generally touchier. We'll just use author/title, keeping things
+    # simple seems to the key to predictable BD results. 
+    title  = raw_search_title(request.referent)
+    author = get_search_creator(request.referent)
+
+    url = BorrowDirect::GenerateQuery.new(@html_query_base_url).normalized_author_title_query(
+      :title  => title,
+      :author => author,
+      :max_title_words => @limit_title_words
+    )
+
+    request.add_service_response( 
+      :service=>self, 
+      :display_text => "Check BorrowDirect for availability",
+      :display_text_i18n => "bd_link_to_search.display_text",
+      :notes => "May be available in BorrowDirect",
+      :notes_i18n => "bd_link_to_search.notes",
+      :url => url, 
+      :service_type_value => :bd_link_to_search)
+  end
+
+end

data/app/views/borrow_direct/_request_form.html.erb

@@ -0,0 +1,22 @@
+<%= form_tag( 
+    borrow_direct_submit_path(:request_id => response.request.id, :service_id => response.service_id),
+    :method => UmlautBorrowDirect::Engine.config.http_submit_method, :role => "form", :class => "form-horizontal borrow-direct-request-form") do %>
+
+
+    <div class="form-group">
+        <div class="col-sm-7 borrow-direct-pickup-col">
+            <%# hidden field empty, used for JQuery Content Utility, the JS consumer
+                may want to fill it in with a whitelisted redirect URL %>
+            <input name="redirect" class="borrow-direct-form-redirect" type="hidden" name="redirect" value="" />
+
+
+            <%= select_tag "pickup_location", options_for_select(response.view_data["pickup_locations"]),
+                         :prompt => I18n.t("umlaut.services.borrow_direct_adaptor.bd_request_prompt.pickup_prompt", :default => "Please choose a delivery location"),
+                         :class => "form-control" %>
+        </div>
+        <div class="col-sm-5 borrow-direct-action-btn-col">
+            <%= submit_tag I18n.t("umlaut.services.borrow_direct_adaptor.bd_request_prompt.request", :default => "Request"), :class => "borrow-direct-action btn btn-primary" %>             
+        </div>
+    </div>
+
+<% end %>

data/app/views/borrow_direct/_resolve_section.html.erb

@@ -0,0 +1,88 @@
+<% bd_presenter = BorrowDirectPresenter.new(renderer) %>
+
+
+<% if bd_presenter.show_link_response?  %>
+    <%# display it the normal way with a standard response type %>
+    <ul class="response_list book-go-icons bd-direct-link">
+        <%= render renderer.item_render_hash(bd_presenter.link_response) %>
+    </ul>
+<% end %>
+
+<% if bd_presenter.show_link_response? && (bd_presenter.show_request_form? || bd_presenter.show_not_available? || bd_presenter.service_in_progress? ) %>
+    <%# separator between link and form when both are present %>
+    <hr>
+<% end %>
+
+<% if bd_presenter.show_confirmation? %>
+    <p class="borrow-direct-confirmation alert alert-success">
+        <%= t("umlaut.services.borrow_direct_adaptor.bd_request_status.confirmation") %>
+        <%= bd_presenter.status_response.view_data["request_number"] %>
+    </p>
+<% end %>
+
+<% if bd_presenter.show_request_form? %>
+    <% if str = bd_presenter.validation_error %>
+        <p class="validation-error text-danger">
+            <%= str %>
+        </p>
+    <% end %>
+    <%= render "borrow_direct/request_form", :response => bd_presenter.request_prompt_response %>
+    <% if bd_presenter.link_response && ! bd_presenter.show_link_response? %>
+        <%= link_to t('umlaut.services.borrow_direct_adaptor.bd_request_prompt.direct_link'), 
+            link_router_url(bd_presenter.link_response),
+            :class => "bd-direct-link",
+            :target => "_blank" %>
+    <% end %>
+<% end %>
+
+<% if bd_presenter.show_not_available?  %>
+    <p class="bd-api-unavailable">        
+        <%= t('umlaut.services.borrow_direct_adaptor.bd_not_available.display_text') %>
+        <% if bd_presenter.link_response %>
+            <%= link_to t('umlaut.services.borrow_direct_adaptor.bd_not_available.workaround_link'), 
+                    link_router_url(bd_presenter.link_response),
+                    :class => "bd-direct-link",
+                    :target => "_blank" %>
+        <% end %>
+    </p>
+
+
+<% end %>
+
+<%# we do custom spinner, so we can customize label for 'placing request' %>
+<% if bd_presenter.service_in_progress?   %>
+    <%= render bd_presenter.spinner_render_hash %>
+<% end %>
+
+<%# do we have an error in the DispatchedService? If so,
+    display a warning at bottom of the section no matter what.
+    Do we have a bd_request_status with an error? Display it too. %>
+
+<% 
+errors = umlaut_request.
+    dispatch_objects_with(:service_type_values => UmlautBorrowDirect.service_type_values).
+    find_all {|ds| ds.failed? }
+if errors.present? 
+    %>
+
+        <% if bd_presenter.show_link_response? && (! bd_presenter.error_div_classes.include?('alert'))%>
+            <hr>
+        <% end %>  
+
+        <%= content_tag "div", :class => bd_presenter.error_div_classes, :role=> "alert" do %>
+            <p> <%= t(bd_presenter.error_message_i18n_key) %>
+                
+                <% if bd_presenter.link_response %>
+                    <%= link_to t('umlaut.display_sections.borrow_direct.workaround_link'), 
+                            link_router_url(bd_presenter.link_response),
+                            :class => "bd-direct-link",
+                            :target => "_blank" %>
+                <% end %>                
+            </p>
+
+            <% if bd_presenter.user_reportable_error %>
+                <p><%= bd_presenter.user_reportable_error %></p>
+            <% end %>
+        <% end %>
+
+<% end %>