skala 0.3.0 → 1.1.0

data/lib/skala/aleph_adapter/get_user_transactions.rb

@@ -0,0 +1,96 @@
+require "nokogiri"
+require "skala/adapter/get_user_transactions"
+require_relative "../aleph_adapter"
+require_relative "./resolve_user"
+
+class Skala::AlephAdapter::GetUserTransactions < Skala::Adapter::GetUserTransactions
+  include parent::ResolveUser
+
+  def call(username, options = {})
+    resolved_user_id = resolve_user(username)
+
+    patron_cash_list = @adapter.restful_api.patron(resolved_user_id).circulationActions.cash.get(view: :full)
+    patron_loan_list = @adapter.restful_api.patron(resolved_user_id).circulationActions.loans.get(view: :full)
+
+    if [patron_cash_list, patron_loan_list].any? { |_response| _response.include?("<error>") }
+      return nil
+    else
+      transactions = []
+
+      # regular credits/debits
+      Nokogiri::XML(patron_cash_list).xpath("//cash").each do |_cash|
+        credit_or_debit = {
+          id: id(_cash),
+          creation_date: creation_date(_cash),
+          record: {
+            id: record_id(_cash)
+          },
+          reason: reason(_cash),
+          type: type(_cash),
+          value: value(_cash),
+          description: description(_cash)
+        }
+
+        transactions << credit_or_debit
+      end
+
+      # unentered debits from loans
+      Nokogiri::XML(patron_loan_list).xpath("//loan").each do |_loan|
+        if fine = _loan.at_xpath("./fine").try(:content).presence
+          transactions << {
+            id: nil,
+            record: {
+              id: record_id(_loan)
+            },
+            reason: :overdue_fine,
+            type: :debit,
+            value: fine.to_f
+          }
+        end
+      end
+
+      self.class::Result.new(
+        transactions: transactions,
+        source: [patron_cash_list, patron_loan_list]
+      )
+    end
+  end
+
+  private
+
+  def creation_date(cash)
+    if date = cash.at_xpath("./z31/z31-date").try(:content).presence
+      Date.strptime(date, "%Y%m%d")
+    end
+  end
+
+  def id(cash)
+    cash.attr("href")[/[^\/]+\Z/][/\A[^?]+/]
+  end
+
+  def record_id(element)
+    element.at_xpath("./z13/z13-doc-number").try(:content).presence
+  end
+
+  def reason(cash)
+    case cash.at_xpath("./z31/z31-type").try(:content).presence
+      when /Kopierauftrag/ then :photocopy_request
+      when /Überfällig/    then :overdue_fine
+    end
+  end
+
+  def type(cash)
+    case cash.attr("type")
+      when "credit" then :credit
+      when "debit"  then :debit
+    end
+  end
+
+  def description(cash)
+    cash.at_xpath("./z31/z31-description").try(:content).presence
+  end
+
+  def value(cash)
+    cash.at_xpath("./z31/z31-sum").try(:content).try(:[], /\d+.\d+/).try(:to_f)
+  end
+end

data/lib/skala/aleph_adapter/renew_user_loan.rb

@@ -0,0 +1,27 @@
+require "nokogiri"
+require "skala/adapter/renew_user_loan"
+require_relative "../aleph_adapter"
+require_relative "./resolve_user"
+
+class Skala::AlephAdapter::RenewUserLoan < Skala::Adapter::RenewUserLoan
+  include parent::ResolveUser
+
+  def call(username, loan_id, options = {})
+    resolved_user_id = resolve_user(username)
+
+    raw_aleph_response = adapter.restful_api.patron(resolved_user_id).circulationActions.loans(loan_id).post
+    reply_code = Nokogiri::XML(raw_aleph_response).at_xpath("//reply-code").try(:content).try(:to_i)
+
+    if reply_code == 0
+      adapter.class::RenewUserLoan::Result.new(
+        source: raw_aleph_response
+      )
+    else
+      if reply_code == 28
+        raise self.class::RenewFailedError
+      else
+        raise adapter.class::RequestFailedError
+      end
+    end
+  end
+end

data/lib/skala/aleph_adapter/renew_user_loans.rb

@@ -0,0 +1,39 @@
+require "nokogiri"
+require "skala/adapter/renew_user_loans"
+require_relative "../aleph_adapter"
+require_relative "./resolve_user"
+
+class Skala::AlephAdapter::RenewUserLoans < Skala::Adapter::RenewUserLoans
+  include parent::ResolveUser
+
+  def call(username, loan_ids = nil, options = {})
+    resolved_user_id = resolve_user(username)
+
+    if loan_ids.blank? # renew all
+      raw_aleph_response = adapter.restful_api.patron(resolved_user_id).circulationActions.loans.post
+      successfully_renewed_loans_xpath = "//loan/status[contains(text(), 'success')]/parent::*"
+
+      adapter.class::RenewUserLoans::Result.new(
+        renewed_loans: begin
+          Nokogiri::XML(raw_aleph_response).xpath(successfully_renewed_loans_xpath).map do |_loan|
+            {
+              id: _loan.attr("id"),
+              due_date: new_due_date(_loan)
+            }
+          end
+        end,
+        source: raw_aleph_response
+      )
+    else
+      raise "Unimplemented"
+    end
+  end
+
+  private
+
+  def new_due_date(loan)
+    if date = loan.at_xpath("./new-due-date").try(:content)
+      Date.strptime(date, "%Y%m%d")
+    end
+  end
+end

data/lib/skala/aleph_adapter/resolve_user.rb

@@ -0,0 +1,19 @@
+require_relative "../aleph_adapter"
+
+module Skala::AlephAdapter::ResolveUser
+  # @depends_on instance methode #adapter
+  def resolve_user(username, options = {})
+    username = username.upcase
+    user_library = options[:user_library] || adapter.default_user_library
+
+    x_services_result = adapter.x_services.post(
+      op: "bor-by-key",
+      bor_id: username,
+      library: user_library
+    )
+
+    x_services_result.match(/<internal-id>(.*)<\/internal-id>/) do |_match_data|
+      _match_data.captures.first
+    end
+  end
+end

data/lib/skala/aleph_adapter/update_user.rb

@@ -0,0 +1,105 @@
+require "skala/adapter/update_user"
+require_relative "../aleph_adapter"
+require_relative "./resolve_user"
+
+class Skala::AlephAdapter::UpdateUser < Skala::Adapter::UpdateUser
+  include parent::ResolveUser
+
+  def call(username, options = {})
+    username = username.upcase # ensure that username/id is always upcased
+    valid_update_options = options.select { |_key, _| respond_to?("update_#{_key}", true) }.to_h
+
+    #
+    # Updating multiple properties in one go is a non trivial task, especially
+    # if one of n updates fails, which implies rollbacks or partial update
+    #
+    if valid_update_options.keys.length > 1
+      raise ArgumentError.new("Only one property can be changed within one call!")
+    elsif valid_update_options.keys.length < 1
+      raise ArgumentError.new("Unknown property to update!")
+    end
+
+    property_name, new_value = [valid_update_options.keys.first, valid_update_options.values.first]
+    send("update_#{property_name}", username, new_value, options)
+  end
+
+  private
+
+  def update_email_address(user_id, new_email_address, options = {})
+    user_library = options[:user_library] || adapter.default_user_library
+    resolved_user_id = resolve_user(user_id)
+
+    raw_aleph_responses = ["01", "02"].map do |_z304_address_type|
+      adapter.x_services.post(
+        op: :update_bor,
+        update_flag: "Y",
+        library: user_library,
+        xml_full_req: <<-XML.strip_heredoc
+          <?xml version="1.0"?>
+          <p-file-20>
+            <patron-record>
+              <z303>
+                <match-id-type>00</match-id-type>
+                <match-id>#{resolved_user_id}</match-id>
+                <record-action>X</record-action>
+              </z303>
+              <z304>
+                <record-action>U</record-action>
+                <z304-id>#{resolved_user_id}</z304-id>
+                <z304-address-type>#{_z304_address_type}</z304-address-type>
+                <z304-sequence>01</z304-sequence>
+                <z304-email-address>#{new_email_address}</z304-email-address>
+              </z304>
+            </patron-record>
+          </p-file-20>
+        XML
+      )
+    end
+
+    if raw_aleph_responses.none? { |_raw_aleph_response| _raw_aleph_response[/Succeeded to REWRITE table z304/] }
+      raise Skala::Adapter::Error
+    end
+
+    return true # if no exception was thrown so far
+  end
+
+  def update_password(user_id, new_password, options = {})
+    user_library = options[:user_library] || adapter.default_user_library
+    resolved_user_id = resolve_user(user_id)
+
+    # we have to change the password for all ids
+    [resolved_user_id, user_id].uniq.each do |_user_id|
+      _id_type = (_user_id == resolved_user_id) ? "00" : "01"
+
+      raw_aleph_response = adapter.x_services.post(
+        op: :update_bor,
+        update_flag: "Y",
+        library: user_library,
+        xml_full_req: <<-XML.strip_heredoc
+          <?xml version="1.0"?>
+          <p-file-20>
+            <patron-record>
+              <z303>
+                <match-id-type>#{_id_type}</match-id-type>
+                <match-id>#{_user_id}</match-id>
+                <record-action>X</record-action>
+              </z303>
+              <z308>
+                <record-action>U</record-action>
+                <z308-key-type>#{_id_type}</z308-key-type>
+                <z308-key-data>#{_user_id}</z308-key-data>
+                <z308-verification>#{new_password}</z308-verification>
+              </z308>
+            </patron-record>
+          </p-file-20>
+        XML
+      )
+
+      unless raw_aleph_response[/Succeeded to REWRITE table z308/]
+        raise Skala::Adapter::Error
+      end
+    end
+
+    return true # if no exception was thrown so far
+  end
+end

data/lib/skala/common_attributes.rb

@@ -0,0 +1,19 @@
+require_relative "../skala"
+
+module Skala::CommonAttributes
+  include Virtus.model
+
+  attribute :ils_record_id
+  attribute :search_engine_record_id
+
+  attribute :contributor
+  attribute :created
+  attribute :creator
+  attribute :creation_date
+  attribute :edition
+  attribute :language
+  attribute :place_of_publication
+  attribute :publisher
+  attribute :signature
+  attribute :title
+end

data/lib/skala/elasticsearch_adapter.rb

@@ -0,0 +1,33 @@
+require "active_support"
+require "active_support/core_ext"
+require "elasticsearch"
+require "skala/adapter"
+
+class Skala::ElasticsearchAdapter < Skala::Adapter
+  require_relative "elasticsearch_adapter/search"
+
+  attr_accessor :hosts
+  attr_accessor :index
+  attr_accessor :timeout
+  attr_accessor :type
+
+  def hosts=(value)
+    @hosts = value.try(:map) { |host| host.deep_symbolize_keys }
+  end
+
+  def initialize(options = {})
+    HashWithIndifferentAccess.new(options).try do |_options|
+      self.hosts   = _options[:hosts] || _options[:host] || _options[:urls] || _options[:url]
+      self.index   = _options[:index]
+      self.timeout = _options[:timeout]
+      self.type    = _options[:type]
+    end
+  end
+
+  #
+  # internal api between adapter and operations
+  #
+  def elasticsearch_client
+    Elasticsearch::Client.new hosts: @hosts
+  end
+end

data/lib/skala/elasticsearch_adapter/search.rb

@@ -0,0 +1,20 @@
+require "skala/adapter/search"
+require_relative "../elasticsearch_adapter"
+
+class Skala::ElasticsearchAdapter::Search < Skala::Adapter::Search
+  require_relative "./search/request_transformation"
+  require_relative "./search/result_transformation"
+
+  def call(search_request, options = {})
+    elasticsearch_request = {
+      body: RequestTransformation.new.call(search_request),
+      index: @adapter.index
+    }
+
+    elasticsearch_result = @adapter.elasticsearch_client.search(elasticsearch_request)
+
+    ResultTransformation.new.call(elasticsearch_result, search_request: search_request)
+  rescue Elasticsearch::Transport::Transport::Errors::BadRequest
+    raise Skala::Adapter::BadRequestError
+  end
+end

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

@@ -0,0 +1,20 @@
+require "transformator/transformation"
+require_relative "../search"
+
+class Skala::ElasticsearchAdapter::Search::RequestTransformation < Transformator::Transformation
+  require_directory "#{File.dirname(__FILE__)}/request_transformation"
+
+  def call(source, options = {})
+    options[:target] ||= {}
+    super(source, options)
+  end
+
+  sequence [
+    AddAggregations,
+    AddFrom,
+    AddQuery,
+    AddSize,
+    AddSort,
+    AddVersion
+  ]
+end

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

@@ -0,0 +1,50 @@
+require "transformator/transformation/step"
+require_relative "../request_transformation"
+
+class Skala::ElasticsearchAdapter::Search::RequestTransformation::
+  AddAggregations < Transformator::Transformation::Step
+
+  def call
+    source.facets.try(:each) do |_facet|
+      target["aggregations"] ||= {}
+
+      elasticsearch_aggregation =
+      if _facet.is_a?(Skala::Adapter::Search::Request::HistogramFacet)
+        {
+          "histogram" => {
+            "field" => _facet.field,
+            "interval" => _facet.interval
+          }
+          .compact
+        }
+      elsif _facet.is_a?(Skala::Adapter::Search::Request::RangeFacet)
+        {
+          "range" => {
+            "field" => _facet.field,
+            "ranges" => _facet.ranges.map do |_range|
+              {
+                "key" => _range.key,
+                "from" => _range.from,
+                "to" => _range.to
+              }
+              .compact
+            end
+          }  
+        }
+      elsif _facet.is_a?(Skala::Adapter::Search::Request::TermsFacet)
+        {
+          "terms" => {
+            "field" => _facet.field,
+            "size" => _facet.size,
+            "shard_size" => (_facet.size * 3 if _facet.size)
+          }
+          .compact
+        }
+      end
+      
+      if elasticsearch_aggregation
+        target["aggregations"][_facet.name] = elasticsearch_aggregation
+      end
+    end
+  end
+end

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

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