umlaut_borrow_direct 1.0.0.pre2

data/config/locales/en.yml

@@ -0,0 +1,40 @@
+en:
+  umlaut:
+    service_type_names:
+      bd_link_to_search:
+        one: BorrowDirect Availability
+        other: BorrowDirect Availability
+      bd_request_prompt: 
+        one: BorrowDirect Availability
+        other: BorrowDirect Availability
+      bd_not_available:
+        one: BorrowDirect Availability
+        other: BorrowDirect Availability
+      bd_request_status:
+        one: BorrowDirect Availability
+        other: BorrowDirect Availability
+    services:
+      borrow_direct_adaptor:
+        bd_link_to_search:
+          display_text: Check BorrowDirect
+          notes: ""
+        bd_request_prompt:
+          pickup_prompt: "Please select a pickup location"
+          request: Request
+          pickup_validation: "You must choose a pickup location"
+          progress: "Checking BorrowDirect availability for you"
+          direct_link: "You can also check BorrowDirect for other editions."
+        bd_not_available:
+          display_text: "This edition is not available via BorrowDirect."
+          workaround_link: "You can check BorrowDirect for other editions."
+        bd_request_status:
+          progress: "Placing the request to BorrowDirect"
+          error:  "There was a problem submitting your request to BorrowDirect."
+          confirmation: "Your request has been submitted to BorrowDirect.  You will receive email confirmation shortly. Request number:"
+    display_sections:
+      borrow_direct:
+        title: "Request a copy from BorrowDirect"
+        prompt: "Get item from one of our partner libraries in 3-6 days. Checkout period is 12 weeks, with no renewals."
+        error: Unable to automatically determine BorrowDirect availability for this edition. 
+        workaround_link: Please check BorrowDirect for this item.
+

data/lib/tasks/umlaut_borrow_direct_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :umlaut_borrow_direct do
+#   # Task goes here
+# end

data/lib/umlaut_borrow_direct/engine.rb

@@ -0,0 +1,41 @@
+require 'umlaut'
+require 'umlaut_borrow_direct/route_set'
+
+module UmlautBorrowDirect
+  class Engine < ::Rails::Engine
+    engine_name "umlaut_borrow_direct"
+
+    # Post is definitely more appropriate, but doens't work with
+    # Shibboleth (and maybe other SSO) protection. Bah. We make
+    # it a config variable, if :post doesn't conflict with your infrastructure,
+    # you could try it. 
+    config.http_submit_method = :get
+
+    initializer "umlaut_borrow_direct.add_service_types" do |app|
+      require 'service_type_value'
+      service_type_hash = Hash[UmlautBorrowDirect.service_type_values.collect {|v| [v, {}] }]
+      ServiceTypeValue.merge_hash! service_type_hash
+    end
+
+    initializer "umlaut_borrow_direct.backtrace_cleaner", :before => "umlaut.backtrace_cleaner" do
+      Umlaut::Engine.config.whitelisted_backtrace[self.root] = self.engine_name
+    end
+
+    initializer "umlaut_borrow_direct.routing" do
+      Rails.application.routes.draw do
+        Umlaut::Routes.register_routes( UmlautBorrowDirect::RouteSet )
+      end
+    end
+
+  initializer "umlaut_borrow_direct.set_api_base" do 
+    # We just set the default api_base in production, hopefully
+    # that won't cause any problems, local app could do something different
+    # in it's own initializer I think. 
+    if Rails.env.production?
+      require 'borrow_direct'
+      BorrowDirect::Defaults.api_base = BorrowDirect::Defaults::PRODUCTION_API_BASE
+    end
+  end
+
+  end
+end

data/lib/umlaut_borrow_direct/route_set.rb

@@ -0,0 +1,17 @@
+module UmlautBorrowDirect
+  # Defines extra routing needed for this plugin. 
+  #
+  # A module that will be mixed into Umlaut::Routes, when we call
+  # Umlaut::Routes.register_routes in an initializer here in our engine
+  module RouteSet
+
+    def borrow_direct
+      add_routes do |options|
+        match "borrow_direct/:service_id/:request_id" => "borrow_direct#submit_request", 
+          :via => UmlautBorrowDirect::Engine.config.http_submit_method,
+          :as => "borrow_direct_submit"
+      end
+    end
+  end
+
+end

data/lib/umlaut_borrow_direct/url_whitelister.rb

@@ -0,0 +1,77 @@
+module UmlautBorrowDirect
+  # Used for whitelisting URLs.  You can specify a whitelist
+  # in terms of a list of partial or complete URLs:
+  #
+  #     "//example.org"         # => Allows any URL at that host, any scheme
+  #     "https://example.org"   # => "Just URLs beginning https://example.org"
+  #     "//example.org/some/path" # => At that host AND with that specific path
+  #
+  # To wildcard hosts, use a trailing period. 
+  #
+  #      "//.example.org" # => Matches any *.example.org or "example.org"
+  #
+  # Whitelist is an array of zero or more such specs. 
+  #
+  # Then you can check:
+  #     URLWhiteLister.new(array_of_specs).whitelisted?(url)
+  #
+  # url can be a string or URI instance. 
+  #
+  class UrlWhitelister
+    attr_reader :whitelist_specs
+
+    # Initialize with an array of one or more valid specs. 
+    def initialize(whitelist_specs)
+      @whitelist_specs = whitelist_specs
+    end
+
+    def whitelisted?(url)
+      return ! self.whitelist_specs.find do | spec |
+        url_whitelisted_by_spec?(url, spec)
+      end.nil?
+    end
+
+    # Does a given URL match a given whitelist spec?
+    # whitelist spec like "//host.tld" or "https://host.tld"
+    # or "//host.tld/path", etc. 
+    #
+    # You can do a wildcard host with a prefix period, for instance
+    # "//.example.org" will match "foo.example.org" as well as "example.org"
+    def url_whitelisted_by_spec?(url, spec)
+      parsed_url = url
+      begin
+        parsed_url  = URI.parse(url) unless parsed_url.kind_of?(URI)
+      rescue URI::InvalidURIError
+        return false
+      end
+
+      parsed_spec = spec.kind_of?(URI) ? spec : URI.parse(spec)
+
+      # Don't include 'host' yet, we check that special for wildcards. 
+      part_list = [:scheme, :userinfo, :port, :path, :query, :fragment]
+
+      # special handling for hosts to support trailing period as wildcard
+      spec_host = parsed_spec.host
+
+      if spec_host && spec_host.start_with?(".")
+        return false unless (parsed_url.host && parsed_url.host.ends_with?(spec_host) || parsed_url.host == spec_host.slice(1..-1))
+      elsif spec_host && (! spec_host.empty?)
+        # just check it normally below
+        part_list << :host
+      end
+
+
+      # Other parts, just match if spec part is not empty
+      part_list.each do |part|
+        spec_part = parsed_spec.send(part).to_s
+        if (! spec_part.nil?) && (! spec_part.empty?) && 
+              (parsed_url.send(part).to_s != spec_part )
+          return false
+        end
+      end
+
+      # If we got this far without a return false, we're good. 
+      return true
+    end
+  end
+end

data/lib/umlaut_borrow_direct/version.rb

@@ -0,0 +1,3 @@
+module UmlautBorrowDirect
+  VERSION = "1.0.0.pre2"
+end

data/lib/umlaut_borrow_direct.rb

@@ -0,0 +1,104 @@
+require "umlaut_borrow_direct/engine"
+
+module UmlautBorrowDirect
+
+  DefaultLocalAvailabilityCheck = proc do |request, service|
+    request.get_service_type(:holding).find do |sr| 
+      UmlautController.umlaut_config.holdings.available_statuses.include?(sr.view_data[:status]) &&
+      sr.view_data[:match_reliability] != ServiceResponse::MatchUnsure 
+    end.present?
+  end
+
+  SectionVisibilityLogic = proc do |section_renderer|
+      (! MetadataHelper.title_is_serial?(section_renderer.request.referent)) &&
+      (
+        (! section_renderer.responses_empty?) || 
+        section_renderer.services_in_progress? ||
+        section_renderer.request.dispatch_objects_with(
+          :service_type_values => UmlautBorrowDirect.service_type_values
+        ).find_all {|ds| ds.failed? }.present?
+      )
+    end
+
+
+  def self.resolve_section_definition
+    # A custom lambda for visibility of our section. 
+    # We want it to be visible if the service is still in progress,
+    # or if it's finished with ServiceResponses generated, OR
+    # if it's finished in an error state. 
+    # Another way to say this, the section will NOT be visible when
+    # the service has finished, without generating responses, or errors. 
+    #
+    # Oh, and don't show it at all unless citation does not pass
+    # MetadataHelper.title_is_serial?. If we don't think it's a serial,
+    # it's not appropriate for BD and no results will be shown, don't show
+    # spinner either. 
+    #
+    # We took the Umlaut SectionRenderer visibility logic for :in_progress,
+    # and added a condition for error state
+    {
+      :div_id     => "borrow_direct",
+      :html_area  => :main,
+      :partial    => "borrow_direct/resolve_section",
+      :visibility => SectionVisibilityLogic,
+      :service_type_values => self.service_type_values,
+      :show_spinner => false # we do our own
+    }
+  end
+
+  # In a local app UmlautController:
+  #     umlaut_config do
+  #        add_section_highlights_filter! UmlautBorrowDirect.section_highlights_filter
+  #
+  # Applies some default rules for white-background-highlighting
+  # of the borrow_direct section. 
+  def self.section_highlights_filter
+    proc {|umlaut_request, sections|
+        # If it's not locally available, remove highlight from 'holding' --
+        # will remove highlights for checked out material for instance. 
+        # And add in document_delivery, although future lines may remove it again
+        # if BD is available.
+        if sections.include?("holding") && ! self.locally_available?(umlaut_request)
+          sections.delete("holding")
+          sections << "document_delivery"
+        end
+
+
+        if ( umlaut_request.get_service_type("bd_link_to_search").present? || 
+             umlaut_request.get_service_type("bd_request_prompt").present? )
+          # highlight BD section and NOT document_delivery if BD section is present
+          sections.delete("document_delivery")
+          sections << "borrow_direct"          
+        end
+
+
+
+
+        # If request is in progress or succesful, highlight it and not docdel. 
+        if umlaut_request.get_service_type("bd_request_status").present?
+          response = umlaut_request.get_service_type("bd_request_status").first
+          if [ BorrowDirectController::InProgress, 
+               BorrowDirectController::Successful].include? response.view_data[:status]
+            sections.delete("document_delivery")
+            sections << "borrow_direct" 
+          elsif BorrowDirectController::Error == response.view_data[:status]
+            sections.delete("document_delivery")
+            sections << "borrow_direct" 
+          end
+        end
+        
+        sections.uniq!
+      }
+  end
+
+  def self.locally_available?(request)
+    aProc = UmlautController.umlaut_config.lookup!("borrow_direct.local_availability_check") || DefaultLocalAvailabilityCheck
+    return aProc.call(request, self)
+  end
+
+  # Array of strings of all service type value names UmlautBorrowDirect does. 
+  def self.service_type_values
+    %w{bd_link_to_search bd_request_prompt bd_not_available bd_request_status}
+  end
+
+end

data/test/borrow_direct_adaptor_test.rb

@@ -0,0 +1,259 @@
+require 'test_helper'
+
+# To run these tests without VCR cassette (or recording new ones), you need to
+# define shell env:
+#    BD_LIBRARY_SYMBOL: Your BD library symbol
+#    BD_PATRON: A barcode of a patron in your library that can be used to auth with BD
+#
+# You MAY need to define, if the defaults aren't accurate for your library/patron:
+#    BD_REQUESTABLE_ISBN: The ISBN of an item that BD will consider requestable
+#       for your patron
+#    BD_NON_REQUESTABLE_ISBN: The ISBN of an item that BD will not consider requestable
+describe "BorrowDirectAdaptor" do
+
+  before do
+    @test_html_query_base_url = "http://example.com/redirect"
+    @service_config = {
+      "type" => "BorrowDirectAdaptor",
+      "priority" => 1,
+      "library_symbol" => VCRFilter[:bd_library_symbol],
+      "find_item_patron_barcode" => VCRFilter[:bd_patron],
+      "html_query_base_url"      => @test_html_query_base_url
+    }
+    @service_config_list = {'default' => {
+      "services" => {
+          "test_bd" => @service_config,
+          "test_holding" => {"type" => "DummyService", "priority" => 1}
+        }
+      }
+    }
+
+    @service = BorrowDirectAdaptor.new(@service_config.merge("service_id" => "test_bd"))
+  end
+
+  it "truncates long titles in search links" do
+    with_service_config(@service_config_list) do
+      request = fake_umlaut_request("resolve?title=Modern+agriculture%2C+based+on+%22Essentials+of+the+new+agriculture%22+by+Henry+Jackson+Waters%2C&aulast=Grimes")
+      @service.make_link_to_search_response(request)
+
+      response = assert_service_responses(request, "test_bd", :number => 1, :includes_type => :bd_link_to_search)
+
+      assert response.view_data[:url].present?
+      url = response.view_data[:url]
+
+      params = CGI.parse(URI.parse(url).query)
+
+      bd_query = params["query"].first
+
+      clauses = bd_query.split(" and ")
+
+      assert(clauses.any? {|c| c == 'au="grimes"'}, "Includes author clause")
+      assert(clauses.any? {|c| c == 'ti="modern agriculture based on essentials"'}, "Includes title clause")
+    end
+  end
+
+  it "does nothing for a non-book-like object" do
+    request = fake_umlaut_request("resolve?sid=google&auinit=RD&aulast=Kaplan&atitle=The+coming+anarchy&title=The+Atlantic+monthly&volume=273&issue=2&date=1994&spage=44&issn=1072-7825")
+
+    @service.handle(request)
+
+    dispatched = request.dispatched_services.to_a.find {|ds| ds.service_id == "test_bd"}
+
+    assert dispatched.present?
+    assert_equal DispatchedService::Successful, dispatched.status
+
+    assert_empty request.service_responses
+  end
+
+  it "creates a search for a book without ISBN" do
+    with_service_config(@service_config_list) do
+      request = fake_umlaut_request("/resolve?sid=google&auinit=EH&aulast=Lenneberg&title=Biological+foundations+of+language&genre=book&date=1967")
+
+      @service.handle(request)
+
+      assert_dispatched request, "test_bd"
+
+      response = assert_service_responses(request, "test_bd", :number => 1, :includes_type => :bd_link_to_search)
+
+      assert response.view_data["url"].present?
+      assert response.view_data["url"].start_with? @test_html_query_base_url
+    end
+  end
+
+
+  describe "for local availability" do
+    before do
+      @available_status = UmlautController.umlaut_config.holdings.available_statuses.first
+    end
+
+    it "suppresses when :holding present with available status" do
+      with_service_config(@service_config_list) do
+        request = fake_umlaut_request("/resolve?title=title&author=au")
+        request.add_service_response(
+          :service => DummyService.new("service_id" => "test_holding", "priority" => 1),
+          :service_type_value => :holding,
+          :status => @available_status
+        )
+
+        @service.handle(request)
+
+        assert_dispatched request, "test_bd"
+
+        assert_service_responses(request, "test_bd", :number => 0)
+      end
+    end
+
+    it "does not suppress for :holding with MatchUnsure" do
+      with_service_config(@service_config_list) do
+        request = fake_umlaut_request("/resolve?title=title&author=au")
+        request.add_service_response(
+          :service => DummyService.new("service_id" => "test_holding", "priority" => 1),
+          :service_type_value => :holding,
+          :match_reliability => ServiceResponse::MatchUnsure,
+          :status => @available_status
+        )
+
+        @service.handle(request)
+
+        assert_dispatched request, "test_bd"
+
+        assert_service_responses(request, "test_bd", :number => 1)
+      end
+    end
+
+    it "does not suppress for holding without available status" do
+      with_service_config(@service_config_list) do
+        request = fake_umlaut_request("/resolve?title=title&author=au")
+        request.add_service_response(
+          :service => DummyService.new("service_id" => "test_holding", "priority" => 1),
+          :service_type_value => :holding,
+          :status => "Checked out really not available can't get it"
+        )
+
+        @service.handle(request)
+
+        assert_dispatched request, "test_bd"
+
+        assert_service_responses(request, "test_bd", :number => 1)
+      end
+
+    end
+
+    describe "with custom local avail check" do
+      before do
+        UmlautController.umlaut_config.borrow_direct ||= {}
+
+        @previous_local_availability_check = UmlautController.umlaut_config.borrow_direct.local_availability_check
+
+        UmlautController.umlaut_config.borrow_direct.local_availability_check = proc do |request, service|
+          false
+        end        
+      end
+
+      after do
+        UmlautController.umlaut_config.borrow_direct.local_availability_check = @previous_local_availability_check        
+      end
+
+      it "uses custom local avail check" do      
+        with_service_config(@service_config_list) do
+          request = fake_umlaut_request("/resolve?title=title&author=au")
+          request.add_service_response(
+            :service => DummyService.new("service_id" => "test_holding", "priority" => 1),
+            :service_type_value => :holding
+          )
+
+          @service.handle(request)
+
+          assert_dispatched request, "test_bd"
+
+          assert_service_responses(request, "test_bd", :number => 1)         
+        end
+      end
+    end
+
+  end
+
+  describe "with live connection to BD", :vcr do
+    it "creates a request form for a requestable item" do
+      with_service_config(@service_config_list) do
+        request = fake_umlaut_request("/resolve?isbn=#{ENV['BD_REQUESTABLE_ISBN'] || '9789810743734'}")
+
+        @service.handle(request)
+
+        assert_dispatched request, "test_bd"
+
+        responses = assert_service_responses(request, "test_bd", :number => 2, :includes_type => [:bd_link_to_search, :bd_request_prompt])
+
+        prompt_response = responses.find {|r| r.service_type_value_name == "bd_request_prompt"}
+        assert prompt_response.view_data["pickup_locations"].present?
+      end
+    end
+
+    it "adds a bd_not_available for confirmed non-requestable item" do
+      with_service_config(@service_config_list) do
+        request = fake_umlaut_request("/resolve?isbn=#{ENV["BD_NON_REQUESTABLE_ISBN"] || '0109836413'}")
+
+        @service.handle(request)
+
+        assert_dispatched request, "test_bd"
+
+        response = assert_service_responses(request, "test_bd", :number => 2, :includes_type => [:bd_not_available, :bd_link_to_search])
+      end
+    end
+
+    it "adds a bd_not_available for an ISBN not in BD at all" do
+      with_service_config(@service_config_list) do
+        request = fake_umlaut_request("/resolve?isbn=000000000")
+
+        @service.handle(request)
+
+        assert_dispatched request, "test_bd"
+
+        response = assert_service_responses(request, "test_bd", :number => 2, :includes_type => [:bd_link_to_search, :bd_not_available])
+      end
+    end
+
+    it "returns a link when BD returns an error" do
+      # Trigger a BD error by giving it a bad library_symbol
+      # We want an error logged, and a link result supplied instead. 
+
+      @service = BorrowDirectAdaptor.new(
+        @service_config.merge("library_symbol" => "BAD_SYMBOL", "service_id" => "test_bd")
+      )      
+
+      with_service_config(@service_config_list) do
+        request = fake_umlaut_request("/resolve?isbn=#{ENV['BD_REQUESTABLE_ISBN'] || '9789810743734'}")
+
+        @service.handle(request)
+
+        assert_dispatched request, "test_bd", DispatchedService::FailedTemporary
+        response = assert_service_responses(request, "test_bd", :number => 1, :includes_type => :bd_link_to_search)
+
+        assert response.view_data["url"].present?
+      end
+    end
+
+  end
+
+  describe "with API use disabled" do
+    # Should not need VCR, because if it's working properly we do not go out
+    # to the API. 
+    it "creates only a search link" do
+      @service = BorrowDirectAdaptor.new(
+        @service_config.merge("use_bd_api" => false, "service_id" => "test_bd")
+      )  
+
+      with_service_config(@service_config_list) do
+        request = fake_umlaut_request("/resolve?isbn=#{ENV['BD_REQUESTABLE_ISBN'] || '9789810743734'}")
+
+        @service.handle(request)
+
+        assert_dispatched request, "test_bd"
+
+        responses = assert_service_responses(request, "test_bd", :number => 1, :includes_type => :bd_link_to_search)
+      end
+    end
+  end
+
+
+end