skala 0.3.0 → 1.1.0

data/lib/skala/elasticsearch_adapter/search/request_transformation/add_query.rb

@@ -0,0 +1,107 @@
+require "transformator/transformation/step"
+require_relative "../request_transformation"
+
+class Skala::ElasticsearchAdapter::Search::RequestTransformation::
+  AddQuery < Transformator::Transformation::Step
+
+  def call
+    [source.queries, source.facet_queries].flatten.compact.presence.try(:each) do |_query|
+      target["query"] ||= {}
+      target["query"]["bool"] ||= {}
+      target["query"]["bool"]["must"] ||= []
+      target["query"]["bool"]["must_not"] ||= []
+
+      if elasticsearch_query = elasticsearch_query_factory(_query)
+        container = _query.exclude ? target["query"]["bool"]["must_not"] : target["query"]["bool"]["must"] 
+        container << elasticsearch_query
+      end
+    end
+  end
+
+  private
+
+  def elasticsearch_query_factory(query)
+    case query.type.to_sym
+    when :query_string        then query_from_query_string_query(query)
+    when :simple_query_string then query_from_simple_query_string_query(query)
+    when :match               then query_from_match_query(query)
+    when :ordered_terms       then query_from_ordered_terms_query(query)
+    when :range               then query_from_range_query(query)
+    when :unscored_terms      then query_from_unscored_terms_query(query)
+    end
+  end
+
+  def query_from_query_string_query(query)
+    {
+      "query_string" => {
+        "default_field"    => query.default_field,
+        "default_operator" => "AND",
+        "fields"           => query.fields,
+        "query"            => query.query
+      }.compact
+    }
+  end
+
+  def query_from_simple_query_string_query(query)
+    {
+      "simple_query_string" => {
+        "default_operator" => query.default_operator,
+        "fields" => query.fields,
+        "query"  => query.query,
+        "analyze_wildcard" => true
+      }
+      .compact
+    }
+  end
+
+  def query_from_match_query(query)
+    {
+      "match" => {
+        query.field => query.query
+      }
+    }
+  end
+
+  def query_from_ordered_terms_query(query)
+    {
+      "bool" => {
+        "should" => query.terms.reverse.map.with_index do |_term, _reversed_index|
+          {
+            "constant_score" => {
+              "filter" => {
+                "term" => {
+                  query.field => _term
+                }
+              },
+              "boost" => _reversed_index
+            }
+          }
+        end,
+      }
+    }
+  end
+
+  def query_from_range_query(query)
+    {
+      "range" => {
+        query.field => {
+          "lte" => query.lte,
+          "gte" => query.gte
+        }
+        .compact
+      }
+    }
+  end
+
+  def query_from_unscored_terms_query(query)
+    {
+      "constant_score" => {
+        "filter" => {
+          "terms" => {
+            query.field => query.terms
+          }
+        }
+      }
+    }
+  end
+end

data/lib/skala/elasticsearch_adapter/search/request_transformation/add_size.rb

@@ -0,0 +1,12 @@
+require "transformator/transformation/step"
+require_relative "../request_transformation"
+
+class Skala::ElasticsearchAdapter::Search::RequestTransformation::
+  AddSize < Transformator::Transformation::Step
+
+  def call
+    source.size.try do |_size|
+      target["size"] = _size
+    end
+  end
+end

data/lib/skala/elasticsearch_adapter/search/request_transformation/add_sort.rb

@@ -0,0 +1,18 @@
+require "transformator/transformation/step"
+require_relative "../request_transformation"
+
+class Skala::ElasticsearchAdapter::Search::RequestTransformation::
+  AddSort < Transformator::Transformation::Step
+
+  def call
+    source.sort.try do |_sort_requests|
+      target["sort"] ||= _sort_requests.map do |_sort_request|
+        if _sort_request.order
+          { _sort_request.field => { order: _sort_request.order } }
+        else
+          _sort_request.field
+        end
+      end
+    end
+  end
+end

data/lib/skala/elasticsearch_adapter/search/request_transformation/add_version.rb

@@ -0,0 +1,10 @@
+require "transformator/transformation/step"
+require_relative "../request_transformation"
+
+class Skala::ElasticsearchAdapter::Search::RequestTransformation::
+  AddVersion < Transformator::Transformation::Step
+
+  def call
+    target["version"] ||= true
+  end
+end

data/lib/skala/elasticsearch_adapter/search/result_transformation.rb

@@ -0,0 +1,21 @@
+require "skala/adapter/search/result"
+require "transformator/transformation"
+require_relative "../search"
+
+class Skala::ElasticsearchAdapter::Search::ResultTransformation < Transformator::Transformation
+  require_directory "#{File.dirname(__FILE__)}/result_transformation"
+
+  attr_accessor :search_request
+
+  def call(source, options = {})
+    options[:target] ||= Skala::Adapter::Search::Result.new(source: source)
+    @search_request = options[:search_request]
+    super(source, options)
+  end
+
+  sequence [
+    SetFacets,
+    SetHits,
+    SetTotalHits
+  ]
+end

data/lib/skala/elasticsearch_adapter/search/result_transformation/set_facets.rb

@@ -0,0 +1,44 @@
+require "transformator/transformation/step"
+require_relative "../result_transformation"
+
+class Skala::ElasticsearchAdapter::Search::ResultTransformation::
+  SetFacets < Transformator::Transformation::Step
+
+  def call
+    if result_aggregations = source["aggregations"]
+      requested_facets = transformation.search_request.facets
+      result_facets = []
+
+      result_aggregations.each do |_key, _value|
+        if requested_facet = requested_facets.find { |_facet| _facet.name == _key }
+
+          result_facets << if requested_facet.is_a?(Skala::Adapter::Search::Request::HistogramFacet)
+            Skala::Adapter::Search::Result::HistogramFacet.new({
+              field: requested_facet.field,
+              name: _key,
+              entries: _value["buckets"].map do |_bucket|
+                {
+                  count: _bucket["doc_count"],
+                  key: _bucket["key"]
+                }
+              end
+            })
+          elsif requested_facet.is_a?(Skala::Adapter::Search::Request::TermsFacet)
+            Skala::Adapter::Search::Result::TermsFacet.new({
+              field: requested_facet.field,
+              name: _key,
+              terms: _value["buckets"].map do |_bucket|
+                {
+                  term: _bucket["key"],
+                  count: _bucket["doc_count"]
+                }
+              end
+            })
+          end
+        end
+      end
+
+      target.facets = result_facets if result_facets.present?
+    end
+  end
+end

data/lib/skala/elasticsearch_adapter/search/result_transformation/set_hits.rb

@@ -0,0 +1,18 @@
+require "transformator/transformation/step"
+require_relative "../result_transformation"
+
+class Skala::ElasticsearchAdapter::Search::ResultTransformation::
+  SetHits < Transformator::Transformation::Step
+
+  def call
+    target.hits = source["hits"]["hits"].map do |_hit|
+      {
+        id: _hit["_id"],
+        index: _hit["_index"],
+        score: _hit["_score"],
+        type: _hit["_type"],
+        version: _hit["_version"]
+      }
+    end
+  end
+end

data/lib/skala/elasticsearch_adapter/search/result_transformation/set_total_hits.rb

@@ -0,0 +1,10 @@
+require "transformator/transformation/step"
+require_relative "../result_transformation"
+
+class Skala::ElasticsearchAdapter::Search::ResultTransformation::
+  SetTotalHits < Transformator::Transformation::Step
+
+  def call
+    target.total_hits = source.try(:[], "hits").try(:[], "total")
+  end
+end

data/lib/skala/engine.rb

@@ -0,0 +1,14 @@
+module Skala
+  class Engine < ::Rails::Engine
+    isolate_namespace Skala
+
+    # http://pivotallabs.com/leave-your-migrations-in-your-rails-engines/
+    #initializer :add_skala_migrations do |app|
+    #  unless app.root.to_s == root.to_s # changed because the original match check fails for us
+    #    config.paths["db/migrate"].expanded.each do |expanded_path|
+    #      app.config.paths["db/migrate"] << expanded_path
+    #    end
+    #  end
+    #end
+  end
+end

data/lib/skala/get_user_result.rb

@@ -0,0 +1,14 @@
+class Skala::GetUserResult
+  include Virtus.model
+
+  attribute :id,                      String
+  attribute :first_name,              String
+  attribute :last_name,               String
+  attribute :email_address,           String
+  attribute :cash_balance,            Float
+  attribute :expiry_date,             Date
+  attribute :number_of_hold_requests, Integer
+  attribute :number_of_loans,         Integer
+
+  attribute :fields
+end

data/lib/skala/hold_request.rb

@@ -0,0 +1,24 @@
+require_relative "../skala"
+require_relative "./record"
+
+class Skala::HoldRequest
+  include Virtus.model
+
+  attribute :id, String
+  attribute :deleteable, Boolean, default: false
+  attribute :place_in_queue, Integer, default: 0
+  attribute :record_id, String
+  attribute :creation_date, Date
+  attribute :begin_request_date, Date
+  attribute :end_request_date, Date
+  attribute :begin_hold_date, Date
+  attribute :end_hold_date, Date
+  attribute :record, Skala::Record
+  attribute :status, Symbol
+
+  # Make sure nil values
+  def place_in_queue=(value)
+    super(value || 0)
+  end
+
+end

data/lib/skala/item.rb

@@ -0,0 +1,15 @@
+class Skala::Item
+  include Virtus.model
+
+  attribute :availability, Symbol
+  attribute :due_date, Date
+  attribute :expected_date, Date
+  attribute :location, String
+  attribute :hold_request_can_be_created, Boolean
+  attribute :id, String
+  attribute :item_status, String
+  attribute :note, Array[String]
+  attribute :number_of_hold_requests, Integer, default: 0
+  attribute :status, Symbol, default: :unknown
+  attribute :record, Skala::Record
+end

data/lib/skala/loan.rb

@@ -0,0 +1,18 @@
+require_relative "../skala"
+
+class Skala::Loan
+  include Virtus.model
+
+  attribute :due_date,      Date
+  attribute :fine,          Float
+  attribute :id,            String, required: true
+  attribute :loan_date,     Date
+  attribute :record,        Skala::Record
+  attribute :renewable,     Axiom::Types::Boolean
+  attribute :returned_date, Date
+  attribute :signature,     String # a loan references a specific item and needs a specific signature
+
+  def renewable?
+    renewable == true
+  end
+end

data/lib/skala/primo_adapter.rb

@@ -0,0 +1,34 @@
+require "active_support"
+require "active_support/core_ext"
+require "skala/adapter"
+
+class Skala::PrimoAdapter < Skala::Adapter
+  require_relative "./primo_adapter/get_records"
+  require_relative "./primo_adapter/search"
+  require_relative "./primo_adapter/soap_api"
+
+  attr_accessor :institution
+  attr_accessor :languages
+  attr_accessor :locations
+  attr_accessor :on_campus
+  attr_accessor :soap_api_url
+  attr_accessor :timeout
+
+  def initialize(options = {})
+    HashWithIndifferentAccess.new(options).try do |_options|
+      self.institution  = _options[:institution]
+      self.languages    = _options[:languages]
+      self.locations    = _options[:locations]
+      self.on_campus    = _options[:on_campus]
+      self.soap_api_url = _options[:soap_api_url] 
+      self.timeout      = _options[:timeout]
+    end
+  end
+
+  #
+  # internal api between adapter and operations
+  #
+  def soap_api
+    self.class::SoapApi.new(self)
+  end
+end

data/lib/skala/primo_adapter/get_records.rb

@@ -0,0 +1,24 @@
+require "skala/adapter/search"
+require_relative "../primo_adapter"
+
+class Skala::PrimoAdapter::GetRecords < Skala::Adapter::GetRecords
+  def call(record_ids, options = {})
+    search_request = Skala::Adapter::Search::Request.new(
+      queries: [
+        {
+          type: "ids",
+          query: [record_ids].flatten(1)
+        }
+      ]
+    )
+
+    search_result = adapter.search(search_request, on_campus: true) # because you know the id -> you searched before
+    self.class::Result.new({records: search_result.hits}).tap do |_get_records_result|
+      _get_records_result.source = search_result.source
+      _get_records_result.each do |_element|
+        _element.found = true
+        _element.version = 1
+      end
+    end
+  end
+end

data/lib/skala/primo_adapter/search.rb

@@ -0,0 +1,13 @@
+require "skala/adapter/search"
+require_relative "../primo_adapter"
+
+class Skala::PrimoAdapter::Search < Skala::Adapter::Search
+  require_relative "./search/request_transformation"
+  require_relative "./search/result_transformation"
+
+  def call(search_request, options = {})
+    primo_soap_request = RequestTransformation.new.call(search_request, adapter, options)
+    primo_result = adapter.soap_api.searchBrief(primo_soap_request)
+    ResultTransformation.new.call(primo_result, search_request: search_request)
+  end
+end

data/lib/skala/primo_adapter/search/request_transformation.rb

@@ -0,0 +1,40 @@
+require "transformator/transformation"
+require_relative "../search"
+
+class Skala::PrimoAdapter::Search::RequestTransformation < Transformator::Transformation
+  extend Forwardable
+
+  require_directory "#{File.dirname(__FILE__)}/request_transformation"
+
+  attr_accessor :adapter
+  attr_accessor :inner_search_request
+  attr_accessor :on_campus
+
+  delegate [:languages, :locations, :institution] => :adapter
+
+  def call(source, adapter, options = {})
+    self.adapter = adapter
+    self.on_campus = options.try(:[], :on_campus)
+    super(source, options)
+  end
+
+  sequence [
+    SetupTarget,
+    SetupInnerSearchRequest,
+    [
+      [
+        AddQueries,
+        SetStartIndex,
+        SetBulkSize,
+        SetLanguages,
+        AddSortByList,
+        SetLocations,
+        SetOnCampus
+      ],
+      SetInstitution
+    ],
+    ToggleBoolOperator,
+    EmbedInnerSearchRequest,
+    SerializeTargetAsXml
+  ]
+end