celsius-primo 0.1.0

data/lib/celsius/primo/soap_api/searcher/search_brief/search_request_transformation/set_start_index.rb

@@ -0,0 +1,12 @@
+require "celsius/transformation/step"
+require "ox"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchRequestTransformation::
+  SetStartIndex < Celsius::Transformation::Step
+
+  def call
+    transformation.inner_search_request.locate("PrimoSearchRequest/StartIndex").first.tap do |node|
+      node << (Celsius::Hash.deep_find_key(source, :from).first.to_i + 1).to_s
+    end
+  end
+end

data/lib/celsius/primo/soap_api/searcher/search_brief/search_request_transformation/setup_inner_search_request.rb

@@ -0,0 +1,32 @@
+require "celsius/transformation/step"
+require "ox"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchRequestTransformation::
+  SetupInnerSearchRequest < Celsius::Transformation::Step
+
+  #
+  # setup inner search request that will be wrapped in a cdata element at the end
+  #
+  def call
+    # we setup this skeleton instead of dynamic element creation because order matters with primo
+    transformation.inner_search_request = Ox.parse(
+      <<-xml
+        <searchRequest xmlns="http://www.exlibris.com/primo/xsd/wsRequest" xmlns:uic="http://www.exlibris.com/primo/xsd/primoview/uicomponents">
+          <PrimoSearchRequest xmlns="http://www.exlibris.com/primo/xsd/search/request">
+            <QueryTerms>
+              <BoolOpeator></BoolOpeator>
+            </QueryTerms>
+            <StartIndex></StartIndex>
+            <BulkSize></BulkSize>
+            <DidUMeanEnabled>false</DidUMeanEnabled>
+            <HighlightingEnabled>false</HighlightingEnabled>
+            <Languages></Languages>
+            <Locations></Locations>
+          </PrimoSearchRequest>
+          <onCampus>false</onCampus>
+          <institution></institution>
+        </searchRequest>
+      xml
+    )
+  end
+end

data/lib/celsius/primo/soap_api/searcher/search_brief/search_request_transformation/setup_target.rb

@@ -0,0 +1,25 @@
+require "celsius/transformation/step"
+require "ox"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchRequestTransformation::SetupTarget < Celsius::Transformation::Step
+  def call
+    # create empty ox document
+    self.target = Ox::Document.new(version: "1.0", encoding: "UTF-8")
+
+    # populate target with soap request skeleton
+    self.target << Ox.parse(
+      <<-xml
+        <env:Envelope
+            xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+            xmlns:impl="http://primo.kobv.de/PrimoWebServices/services/searcher"
+            xmlns:env="http://schemas.xmlsoap.org/soap/envelope/"
+            xmlns:ins0="http://xml.apache.org/xml-soap">
+          <env:Body>
+            <impl:searchBrief><searchRequestStr></searchRequestStr></impl:searchBrief>
+          </env:Body>
+        </env:Envelope>
+      xml
+    )
+  end
+end

data/lib/celsius/primo/soap_api/searcher/search_brief/search_request_transformation.rb

@@ -0,0 +1,59 @@
+require "celsius/primo/soap_api/searcher/search_brief"
+require "celsius/transformation"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchRequestTransformation < Celsius::Transformation
+  require_directory "#{File.dirname(__FILE__)}/search_request_transformation"
+
+  sequence [
+    SetupTarget,
+    SetupInnerSearchRequest,
+    [
+      [ 
+        ProcessMatchQueries,
+        ProcessQueryStringQueries,
+        ProcessRangeQueries,
+        ProcessIdsQueries,
+        SetStartIndex,
+        SetBulkSize,
+        SetLanguages,
+        AddSortByList,
+        SetLocations
+      ],
+      SetInstitution
+    ],
+    EmbedInnerSearchRequest,
+    SerializeTargetAsXml
+  ]
+
+  attr_accessor :languages
+  attr_accessor :locations
+  attr_accessor :institution
+  attr_accessor :inner_search_request
+
+  def initialize(options = {})
+    @languages = options[:languages]
+    @locations = options[:locations]
+    @institution = options[:institution]
+  end
+
+  def index_field_mapping(index_field)
+    case index_field
+    when "_all"       then "any"
+    when "created"    then "cdate"
+    when "identifier" then "any"
+    when "language"   then "lang"
+    when "subject"    then "sub"
+    else index_field
+    end
+  end
+
+  def sort_field_mapping(sort_field)
+    case sort_field
+    when "_score"  then "relevance"
+    when "created" then "scdate"
+    when "creator" then "screator"
+    when "title"   then "stitle"
+    else sort_field
+    end
+  end
+end

data/lib/celsius/primo/soap_api/searcher/search_brief/search_result_transformation/add_missing_facets.rb

@@ -0,0 +1,45 @@
+require "celsius/transformation/step"
+require "ox"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchResultTransformation::
+  AddMissingFacets < Celsius::Transformation::Step
+
+  #
+  # Sometimes, requested facets do not show up in search result, so we have to (re)add them
+  #
+  def call
+    if match_queries = Celsius::Hash.deep_find_key(search_request, :match)
+      binding.pry
+      raise "unimplemented!"
+    end
+  end
+
+  #
+  private
+  #
+=begin
+  # handle primo bug where requested facets don't show up in search response
+  process "//match", source: -> { @search_request} do |match, target|
+    if (target_facet_name = match.nodes.first.value).start_with?("facet_")
+      target_facet_value =  match.nodes.first.text
+      target_facet_count = find_all(@search_brief_return, "SEGMENTS/JAGROOT/RESULT/DOCSET/DOC").length
+
+      # case 1 - there is no facet at all
+      unless find(target, "facets/#{target_facet_name}")
+        find(target, "facets") << element(target_facet_name) do |target_facet|
+          target_facet << element("_type", text: "terms")
+          target_facet << array("terms")
+        end
+      end
+
+      # case 2 - there is a facet, but the requested facet is not included
+      unless find_all(target, "facets/#{target_facet_name}/terms/terms/term").map(&:text).include?(target_facet_value)
+        array(find(target, "facets/#{target_facet_name}/terms")) do |term|
+          term << element("term", text: target_facet_value)
+          term << element("count", text: target_facet_count.to_s, type: "integer")
+        end
+      end
+    end
+  end
+=end
+end

data/lib/celsius/primo/soap_api/searcher/search_brief/search_result_transformation/parse_inner_search_brief_return.rb

@@ -0,0 +1,23 @@
+require "celsius/transformation/step"
+require "ox"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchResultTransformation::
+  ParseInnerSearchBriefReturn < Celsius::Transformation::Step
+
+  def call
+    remove_namespaces!(source)
+
+    string_encoded_search_brief_return =
+    Ox.parse(source).locate("Envelope/Body/searchBriefResponse/searchBriefReturn").first
+
+    transformation.search_brief_return =
+    Ox.parse remove_namespaces!(string_encoded_search_brief_return.text)
+  end
+
+  #
+  private
+  #
+  def remove_namespaces!(xml)
+    xml.gsub!(/<(\/?)\w+:(\w+)/, "<\\1\\2")
+  end
+end

data/lib/celsius/primo/soap_api/searcher/search_brief/search_result_transformation/process_facets.rb

@@ -0,0 +1,29 @@
+require "celsius/transformation/step"
+require "ox"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchResultTransformation::
+  ProcessFacets < Celsius::Transformation::Step
+
+  def call
+    if source_facets = search_brief_return.locate("JAGROOT/RESULT/FACETLIST/FACET")
+      source_facets.each do |source_facet|
+        target["facets"]["facet_#{source_facet["NAME"]}"] = target_facet(source_facet)
+      end
+    end
+  end
+
+  #
+  private
+  #
+  def target_facet(source_facet)
+    {
+      "_type" => "terms",
+      "terms" => source_facet.locate("FACET_VALUES").map do |source_facet_value|
+        {
+          "term" => source_facet_value["KEY"].force_encoding("utf-8"),
+          "count" => source_facet_value["VALUE"].to_i
+        }
+      end
+    }
+  end
+end

data/lib/celsius/primo/soap_api/searcher/search_brief/search_result_transformation/process_records.rb

@@ -0,0 +1,80 @@
+require "celsius/transformation/step"
+require "ox"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchResultTransformation::
+  ProcessRecords < Celsius::Transformation::Step
+
+  def call
+    add_records!(transformation.target).each do |record|
+      [
+        { "_source/control/recordid"     => "_id" },
+        { "_source/display/creator"      => "creator" },
+        { "_source/display/creationdate" => "created" },
+        { "_source/display/description"  => "description" },
+        { "_source/display/edition"      => "edition" },
+        { "_source/display/format"       => "format" },
+        { "_source/control/ilsapiid"     => "identifier" },
+        { "_source/control/recordid"     => "identifier" },
+        { "_source/search/isbn"          => "isbn" },
+        { "_source/search/issn"          => "issn" },
+        { "_source/display/language"     => "language" },
+        { "_source/display/title"        => "title" },
+        { "_source/display/publisher"    => "publisher" },
+        { "_source/display/subject"      => "subject" }
+      ].each do |mapping|
+        map_record_field!(record, mapping.keys.first, mapping.values.first)
+      end
+
+      add_place_of_publication!(record)
+    end
+  end
+
+  #
+  private
+  #
+  def add_place_of_publication!(record)
+    if record["publisher"]
+      record["publisher"].match(/(\A[^:]*):(.*)/) do |match|
+        place_of_publication, publisher = match.captures.map(&:strip)
+        
+        record["placeOfPublication"] = place_of_publication
+        record["publisher"].replace(publisher)
+      end
+    end
+  end
+  
+  def add_records!(target)
+    (search_brief_return.locate("JAGROOT/RESULT/DOCSET/DOC") || []).each do |source_record|
+      target["hits"]["hits"].push({
+        "_type" => "record",
+        "_source" => source_record.locate("PrimoNMBib/record/?").inject({}) do |_source, section|
+          _source.merge! section.value => transformation.hash_from_ox_element(section)
+        end
+      })
+    end
+
+    target["hits"]["hits"] # for chaining
+  end
+
+  def map_record_field!(record, source_path, target_path)
+    source_value = resolve_path(record, source_path)
+    target = resolve_path(record, target_path, -2)
+    target_key = target_path.split("/").last
+
+    if target[target_key]
+      target[target_key] = [target[target_key]]
+    end
+
+    if target[target_key].is_a?(Array)
+      (target[target_key] << source_value).flatten(1)
+    else
+      target[target_key] = source_value
+    end
+  end
+
+  def resolve_path(object, path, level = -1)
+    path.split("/").slice(0..level).inject(object) do |_object, key|
+      _object[key] unless _object.nil?
+    end
+  end
+end

data/lib/celsius/primo/soap_api/searcher/search_brief/search_result_transformation/remove_bogus_creationdate_facets.rb

@@ -0,0 +1,15 @@
+require "celsius/transformation/step"
+require "ox"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchResultTransformation::
+  RemoveBogusCreationdateFacets < Celsius::Transformation::Step
+
+  #
+  # Sometimes, there are creationdate facets entries 1 and 500, which are bogus
+  #
+  def call
+    ((target["facets"]["facet_creationdate"] || {})["terms"] || []).reject! do |element|
+      element["term"] == "1" || element["term"] == "500"
+    end
+  end
+end

data/lib/celsius/primo/soap_api/searcher/search_brief/search_result_transformation/select_only_requested_facets.rb

@@ -0,0 +1,14 @@
+require "celsius/transformation/step"
+require "ox"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchResultTransformation::
+  SelectOnlyRequestedFacets < Celsius::Transformation::Step
+
+  def call
+    if requested_facets_names = Celsius::Hash.deep_find_key(search_request, [:facets, :field])
+      target["facets"].select! do |target_facet_name, _|
+        requested_facets_names.include?(target_facet_name)
+      end
+    end
+  end
+end

data/lib/celsius/primo/soap_api/searcher/search_brief/search_result_transformation/set_total_hits.rb

@@ -0,0 +1,12 @@
+require "celsius/transformation/step"
+require "ox"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchResultTransformation::
+  SetTotalHits < Celsius::Transformation::Step
+
+  def call
+    if docset = (search_brief_return.locate("JAGROOT/RESULT/DOCSET") || []).first
+      target["hits"]["total"] = docset[:TOTALHITS].to_i
+    end
+  end
+end

data/lib/celsius/primo/soap_api/searcher/search_brief/search_result_transformation/setup_target_skeleton.rb

@@ -0,0 +1,17 @@
+require "celsius/transformation/step"
+require "ox"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchResultTransformation::
+  SetupTargetSkeleton < Celsius::Transformation::Step
+
+  def call
+    transformation.target = {
+      "took" => nil,
+      "hits" => {
+        "hits" => [],
+        "total" => 0
+      },
+      "facets" => {}
+    }    
+  end
+end

data/lib/celsius/primo/soap_api/searcher/search_brief/search_result_transformation/sort_facets_by_search_request.rb

@@ -0,0 +1,21 @@
+require "celsius/transformation/step"
+require "ox"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchResultTransformation::
+  SortFacetsBySearchRequest < Celsius::Transformation::Step
+
+  def call
+    if requested_facets_names = Celsius::Hash.deep_find_key(search_request, [:facets, :field])
+      original_target_facets = target["facets"]
+
+      # ruby has a order-preserving hash, so sorting means recreating with the desired order
+      target["facets"] = {}.tap do |target_facets|
+        requested_facets_names.each do |facet_name|
+          if original_target_facet_value = original_target_facets[facet_name]
+            target_facets[facet_name] = original_target_facet_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/celsius/primo/soap_api/searcher/search_brief/search_result_transformation.rb

@@ -0,0 +1,59 @@
+require "celsius/primo/soap_api/searcher/search_brief"
+require "celsius/transformation"
+
+class Celsius::Primo::SoapApi::Searcher::SearchBrief::SearchResultTransformation < Celsius::Transformation
+  require_directory "#{File.dirname(__FILE__)}/search_result_transformation"
+
+  sequence [
+    ParseInnerSearchBriefReturn,
+    SetupTargetSkeleton,
+    SetTotalHits,
+    [ # facets
+      ProcessFacets,
+      AddMissingFacets,
+      RemoveBogusCreationdateFacets,
+      SelectOnlyRequestedFacets,
+      SortFacetsBySearchRequest
+    ],
+    ProcessRecords
+  ]
+
+  attr_accessor :search_brief_return
+  attr_accessor :search_request
+
+  def initialize(options = {})
+    @search_request = options[:search_request]
+  end
+
+  def hash_from_ox_element(ox_element)
+    OxHelpers.hash_from_ox_element(ox_element)
+  end
+
+  module OxHelpers
+    def self.hash_from_ox_element(ox_element)
+      if string_element?(ox_element)
+        ox_element.first.force_encoding("utf-8")
+      else
+        ox_element.nodes.inject({}) do |hash, node|
+          key = node.value
+
+          if hash[key].is_a?(String)
+            hash[key] = [hash[key]]
+          end
+
+          if hash[key].is_a?(Array)
+            hash[key] << hash_from_ox_element(node.nodes)
+          else
+            hash[key] = hash_from_ox_element(node.nodes)
+          end
+
+          hash
+        end
+      end
+    end
+
+    def self.string_element?(ox_element)
+      ox_element.is_a?(Array) && ox_element.length == 1 && ox_element.first.is_a?(String)
+    end
+  end
+end