skala 0.3.0 → 1.1.0

data/lib/skala/adapter/search/request/ids_query.rb

@@ -0,0 +1,6 @@
+require_relative "../request"
+require_relative "./query"
+
+class Skala::Adapter::Search::Request::IdsQuery < Skala::Adapter::Search::Request::Query
+  attribute :query, Array[BasicObject], required: true
+end

data/lib/skala/adapter/search/request/match_query.rb

@@ -0,0 +1,7 @@
+require_relative "../request"
+require_relative "./query"
+
+class Skala::Adapter::Search::Request::MatchQuery < Skala::Adapter::Search::Request::Query
+  attribute :field, String, required: true
+  attribute :query, String, required: true
+end

data/lib/skala/adapter/search/request/ordered_terms_query.rb

@@ -0,0 +1,7 @@
+require_relative "../request"
+require_relative "./query"
+
+class Skala::Adapter::Search::Request::OrderedTermsQuery < Skala::Adapter::Search::Request::Query
+  attribute :field, String,             required: true
+  attribute :terms, Array[BasicObject], required: true
+end

data/lib/skala/adapter/search/request/query.rb

@@ -0,0 +1,18 @@
+require_relative "../request"
+
+class Skala::Adapter::Search::Request::Query
+  include Virtus.model
+
+  attribute :exclude, Axiom::Types::Boolean, default: false
+
+  # unless given, interfere the query type from the class name
+  attribute :type, String, default: -> (instance, _) do
+    query_name = instance.class.to_s.demodulize.underscore
+
+    if (splitted_query_name = query_name.split("_")).last == "query"
+      splitted_query_name[0..-2].join("_")
+    else
+      query_name
+    end
+  end
+end

data/lib/skala/adapter/search/request/query_string_query.rb

@@ -0,0 +1,9 @@
+require_relative "../request"
+require_relative "./query"
+
+class Skala::Adapter::Search::Request::QueryStringQuery < Skala::Adapter::Search::Request::Query
+  attribute :default_field,    String, lazy: true
+  attribute :default_operator, String, default: "AND"
+  attribute :fields,           Array[String], laze: true
+  attribute :query,            String, required: true
+end

data/lib/skala/adapter/search/request/range_facet.rb

@@ -0,0 +1,10 @@
+require_relative "../request"
+require_relative "./facet"
+
+class Skala::Adapter::Search::Request::RangeFacet < Skala::Adapter::Search::Request::Facet
+  require_relative "./range_facet/range"
+
+  attribute :field,  String,       required: true
+  attribute :name,   String,       required: true
+  attribute :ranges, Array[Range], required: true
+end

data/lib/skala/adapter/search/request/range_facet/range.rb

@@ -0,0 +1,9 @@
+require_relative "../range_facet"
+
+class Skala::Adapter::Search::Request::RangeFacet::Range
+  include Virtus.model
+
+  attribute :from, BasicObject, lazy: true
+  attribute :key,  String,      required: true
+  attribute :to,   BasicObject, lazy: true
+end

data/lib/skala/adapter/search/request/range_query.rb

@@ -0,0 +1,8 @@
+require_relative "../request"
+require_relative "./query"
+
+class Skala::Adapter::Search::Request::RangeQuery < Skala::Adapter::Search::Request::Query
+  attribute :field, String,      required: true
+  attribute :gte,   BasicObject, lazy: true
+  attribute :lte,   BasicObject, lazy: true
+end

data/lib/skala/adapter/search/request/simple_query_string_query.rb

@@ -0,0 +1,8 @@
+require_relative "../request"
+require_relative "./query"
+
+class Skala::Adapter::Search::Request::SimpleQueryStringQuery < Skala::Adapter::Search::Request::Query
+  attribute :default_operator, String,        default: "AND"
+  attribute :fields,           Array[String], required: true
+  attribute :query,            String,        required: true
+end

data/lib/skala/adapter/search/request/sort_request.rb

@@ -0,0 +1,15 @@
+require_relative "../request"
+
+class Skala::Adapter::Search::Request::SortRequest
+  include Virtus.model
+
+  class Order < Virtus::Attribute
+    def coerce(value)
+      value = value.try(:to_s).try(:downcase)
+      ["asc", "desc"].include?(value) ? value : nil
+    end
+  end
+
+  attribute :field, String, required: true
+  attribute :order, Order,  lazy: true
+end

data/lib/skala/adapter/search/request/terms_facet.rb

@@ -0,0 +1,8 @@
+require_relative "../request"
+require_relative "./facet"
+
+class Skala::Adapter::Search::Request::TermsFacet < Skala::Adapter::Search::Request::Facet
+  attribute :field, String, required: true
+  attribute :name,  String, required: true
+  attribute :size,  Integer, lazy: true
+end

data/lib/skala/adapter/search/request/unscored_terms_query.rb

@@ -0,0 +1,7 @@
+require_relative "../request"
+require_relative "./query"
+
+class Skala::Adapter::Search::Request::UnscoredTermsQuery < Skala::Adapter::Search::Request::Query
+  attribute :field, String,             required: true
+  attribute :terms, Array[BasicObject], required: true
+end

data/lib/skala/adapter/search/result.rb

@@ -0,0 +1,22 @@
+require_relative "../search"
+
+class Skala::Adapter::Search::Result < Skala::Adapter::Operation::Result
+  include Enumerable
+  include Virtus.model
+
+  # facets
+  require_relative "./result/facet"
+  require_relative "./result/histogram_facet"
+  require_relative "./result/terms_facet"
+
+  # other
+  require_relative "./result/hit"
+
+  attribute :facets,     Array[Facet], lazy: true
+  attribute :hits,       Array[Hit],   lazy: true
+  attribute :total_hits, Integer,      default: 0
+
+  def each
+    block_given? ? hits.each { |_element| yield _element } : hits.each
+  end
+end

data/lib/skala/adapter/search/result/facet.rb

@@ -0,0 +1,15 @@
+require_relative "../result"
+
+class Skala::Adapter::Search::Result::Facet
+  include Virtus.model
+
+  attribute :type, String, default: -> (instance, _) do
+    class_name = instance.class.to_s.demodulize.underscore
+
+    if (splitted_class_name = class_name.split("_")).last == "facet"
+      splitted_class_name[0..-2].join("_")
+    else
+      class_name
+    end
+  end
+end

data/lib/skala/adapter/search/result/histogram_facet.rb

@@ -0,0 +1,12 @@
+require_relative "../result"
+require_relative "./facet"
+
+class Skala::Adapter::Search::Result::HistogramFacet < Skala::Adapter::Search::Result::Facet
+  require_relative "./histogram_facet/entry"
+  
+  include Virtus.model
+
+  attribute :entries, Array[Entry]
+  attribute :field,   String
+  attribute :name,    String, required: true
+end

data/lib/skala/adapter/search/result/histogram_facet/entry.rb

@@ -0,0 +1,8 @@
+require_relative "../histogram_facet"
+
+class Skala::Adapter::Search::Result::HistogramFacet::Entry
+  include Virtus.model
+
+  attribute :count, Integer, required: true
+  attribute :key,   String,  required: true
+end

data/lib/skala/adapter/search/result/hit.rb

@@ -0,0 +1,13 @@
+require "skala/record"
+require_relative "../result"
+
+class Skala::Adapter::Search::Result::Hit
+  include Virtus.model
+
+  attribute :id,      String, required: true
+  attribute :index,   String
+  attribute :score,   BasicObject # TODO: can we set this to Float ?
+  attribute :type,    String
+  attribute :record,  Skala::Record
+  attribute :version, Integer
+end

data/lib/skala/adapter/search/result/terms_facet.rb

@@ -0,0 +1,14 @@
+require_relative "../result"
+require_relative "./facet"
+
+class Skala::Adapter::Search::Result::TermsFacet < Skala::Adapter::Search::Result::Facet
+  require_relative "./terms_facet/term"
+
+  include Virtus.model
+
+  attribute :field, String
+  attribute :name,  String
+  attribute :terms, Array[Term]
+
+  # attr_accessor :i18n_key # TODO: remove
+end

data/lib/skala/adapter/search/result/terms_facet/term.rb

@@ -0,0 +1,8 @@
+require_relative "../terms_facet"
+
+class Skala::Adapter::Search::Result::TermsFacet::Term
+  include Virtus.model
+
+  attribute :count, Integer, required: true
+  attribute :term,  String,  required: true
+end

data/lib/skala/adapter/update_user.rb

@@ -0,0 +1,4 @@
+require_relative "../adapter"
+
+class Skala::Adapter::UpdateUser < Skala::Adapter::Operation
+end

data/lib/skala/aleph_adapter.rb

@@ -0,0 +1,47 @@
+require "active_support"
+require "active_support/core_ext"
+require "aleph_api"
+require "skala/adapter"
+
+class Skala::AlephAdapter < Skala::Adapter
+  require_relative "aleph_adapter/authenticate_user"
+  require_relative "aleph_adapter/create_user_hold_request"
+  require_relative "aleph_adapter/delete_user_hold_request"
+  #require_relative "aleph_adapter/get_record"
+  require_relative "aleph_adapter/get_record_holdable_items"
+  require_relative "aleph_adapter/get_record_items"
+  require_relative "aleph_adapter/get_user"
+  require_relative "aleph_adapter/get_user_former_loans"
+  require_relative "aleph_adapter/get_user_hold_requests"
+  require_relative "aleph_adapter/get_user_inter_library_loans"
+  require_relative "aleph_adapter/get_user_loans"
+  require_relative "aleph_adapter/get_user_transactions"
+  require_relative "aleph_adapter/renew_user_loan"
+  require_relative "aleph_adapter/renew_user_loans"
+  require_relative "aleph_adapter/update_user"
+
+  attr_accessor :default_document_base
+  attr_accessor :default_user_library
+  attr_accessor :restful_api_url
+  attr_accessor :x_services_url
+
+  def initialize(options = {})
+    HashWithIndifferentAccess.new(options).try do |_options|
+      self.default_document_base = _options[:default_document_base]
+      self.default_user_library = _options[:default_user_library]
+      self.restful_api_url = _options[:restful_api_url]
+      self.x_services_url = _options[:x_services_url]
+    end
+  end
+
+  #
+  # apis used to implemented the operations
+  #
+  def restful_api
+    @restful_api ||= AlephApi::RestfulApiClient.new(url: @restful_api_url)
+  end
+
+  def x_services
+    @x_services ||= AlephApi::XServicesClient.new(url: @x_services_url)
+  end
+end

data/lib/skala/aleph_adapter/authenticate_user.rb

@@ -0,0 +1,27 @@
+require_relative "../aleph_adapter"
+
+module Skala
+  class AlephAdapter::AuthenticateUser
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    def call(user_id, password)
+      @adapter.x_services.post(
+        op: :"bor-auth",
+        bor_id: user_id,
+        library: @adapter.default_user_library,
+        verification: password
+      )
+      .try do |_response|
+        if  _response.include?("<z303>")
+          true
+        elsif  _response.include?("error")
+          false
+        else
+          StandardError.new
+        end
+      end
+    end
+  end
+end

data/lib/skala/aleph_adapter/create_user_hold_request.rb

@@ -0,0 +1,63 @@
+require "nokogiri"
+require "skala/adapter/create_user_hold_request"
+require_relative "../aleph_adapter"
+require_relative "./resolve_user"
+
+class Skala::AlephAdapter::CreateUserHoldRequest < Skala::Adapter::CreateUserHoldRequest
+  include parent::ResolveUser
+
+  def call(username, document_number, options = {})
+    get_record_items_result = adapter.get_record_items(
+      document_number, {
+        username: username,
+      }
+    )
+
+    if first_holdable_item = get_record_items_result.items.find(&:hold_request_can_be_created)
+      document_base = options[:document_base] || adapter.default_document_base
+      record_id = "#{document_base}#{document_number}"
+      resolved_user_id = resolve_user(username)
+
+      raw_aleph_response = adapter.restful_api.patron(resolved_user_id).record(record_id).holds.get(view: :full)
+      doc = Nokogiri::XML(raw_aleph_response)
+
+      if element = doc.at_xpath("//group/item-status[text() = '#{first_holdable_item.item_status}']/parent::*")
+        group_id = element.attr("href").split("/").last
+        pickup_location = element.xpath("./pickup-locations/pickup-location").first.try(:attr, "code")
+        start_interest_date = Date.today.strftime("%Y%m%d")
+        last_interest_date = (Date.today + 1.year).strftime("%Y%m%d")
+
+        raw_aleph_response = adapter.restful_api.patron(resolved_user_id).record(record_id).holds(group_id).put(
+          [
+            "post_xml=",
+            "<hold-request-parameters>",
+              "<pickup-location>#{pickup_location}</pickup-location>",
+              "<start-interest-date>#{start_interest_date}</start-interest-date>",
+              "<last-interest-date>#{last_interest_date}</last-interest-date>",
+            "</hold-request-parameters>"
+          ].join # !!! do not add linebreaks or something else or it will fail
+        )
+
+        reply_code = Nokogiri::XML(raw_aleph_response).at_xpath("//reply-code").try(:content).to_i
+
+        if [1, 2, 19, 21].include?(reply_code)
+          raise adapter.class::BadRequestError
+        elsif [25].include?(reply_code)
+          if raw_aleph_response[/Patron has already requested this item/]
+            raise self.class::AlreadyRequestedError
+          else
+            raise adapter.class::RequestFailedError
+          end
+        else
+          adapter.class::CreateUserHoldRequest::Result.new(
+            source: raw_aleph_response
+          )
+        end
+      else
+        raise adapter.class::BadRequestError
+      end
+    else
+      raise adapter.class::BadRequestError
+    end
+  end
+end

data/lib/skala/aleph_adapter/delete_user_hold_request.rb

@@ -0,0 +1,29 @@
+require "nokogiri"
+require "skala/adapter/delete_user_hold_request"
+require_relative "../aleph_adapter"
+require_relative "./resolve_user"
+
+class Skala::AlephAdapter::DeleteUserHoldRequest < Skala::Adapter::DeleteUserHoldRequest
+  include parent::ResolveUser
+
+  def call(username, hold_request_id, options = {})
+    document_base = options[:document_base] || adapter.default_document_base
+    record_id = "#{document_base}#{record_id}"
+    resolved_user_id = resolve_user(username)
+
+    raw_aleph_response = @adapter.restful_api.patron(resolved_user_id).circulationActions.requests.holds(hold_request_id).delete
+    reply_code = Nokogiri::XML(raw_aleph_response).at_xpath("//reply-code").try(:content).try(:to_i)
+
+    if reply_code == 0
+      adapter.class::DeleteUserHoldRequest::Result.new(
+        source: raw_aleph_response
+      )
+    else
+      if reply_code == 8
+        raise self.class::HoldRequestMissingError
+      else
+        raise adapter.class::RequestFailedError
+      end
+    end
+  end
+end

data/lib/skala/aleph_adapter/get_record.rb

@@ -0,0 +1,22 @@
+require_relative "../aleph_adapter"
+
+module Skala
+  class AlephAdapter::GetRecord
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    def call(record_id)
+      get_record = @adapter.restful_api.record(record_id).get(view: :full)
+
+      {
+        "_type" => "record",
+        "_id" => record_id,
+        "fields" => {
+          "record" => "#{get_record[/<?.*?>/]}#{WeakXml.find("<record>", get_record).to_s}"
+        },
+        "_source" => get_record
+      }
+    end
+  end
+end

data/lib/skala/aleph_adapter/get_record_holdable_items.rb

@@ -0,0 +1,29 @@
+require "nokogiri"
+require "skala/adapter/get_record_holdable_items"
+require_relative "../aleph_adapter"
+require_relative "./get_record_items"
+
+class Skala::AlephAdapter::GetRecordHoldableItems < Skala::Adapter::GetRecordHoldableItems
+  def call(document_number, username, options = {})
+    get_record_items_result = get_record_items(document_number, options.merge(username: username))
+
+    self.class::Result.new(
+      holdable_items: holdable_items(get_record_items_result),
+      source: get_record_items_result.source
+    )
+  end
+
+  private
+
+  def get_record_items(*args)
+    adapter.class::GetRecordItems.new(adapter).call(*args) # adapter.class is important to get inherited op
+  end
+
+  def holdable_items(get_record_items_result)
+    source_doc = Nokogiri::XML(get_record_items_result.source)
+
+    get_record_items_result.items.select do |_item|
+      !!source_doc.at_xpath("//item/info[@type='HoldRequest' and contains(@href, _item.id) and @allowed='Y']")
+    end
+  end
+end