skala 0.3.0 → 1.1.0

data/lib/skala/aleph_adapter/get_record_items.rb

@@ -0,0 +1,111 @@
+require "nokogiri"
+require "skala/adapter/get_record_items"
+require_relative "../aleph_adapter"
+require_relative "./resolve_user"
+
+class Skala::AlephAdapter::GetRecordItems < Skala::Adapter::GetRecordItems
+  include parent::ResolveUser
+
+  def call(document_number, options = {})
+    document_base = options[:document_base] || @adapter.default_document_base
+    record_id = "#{document_base}#{document_number}"
+    resolved_user_id = resolve_user(options[:username]) if options[:username]
+
+    aleph_options = { patron: resolved_user_id, view: :full }.compact
+    raw_aleph_response = adapter.restful_api.record(record_id).items.get(aleph_options)
+
+    if raw_aleph_response.include?("<error>")
+      return nil
+    else
+      self.class::Result.new(
+        items: Nokogiri::XML(raw_aleph_response).xpath("//item").map do |_item|
+          {
+            id: id(_item),
+            availability: availability(_item),
+            due_date: due_date(_item),
+            expected_date: expected_date(_item),
+            hold_request_can_be_created: hold_request_can_be_created(_item),
+            item_status: item_status(_item),
+            number_of_hold_requests: number_of_hold_requests(_item),
+            note: note(_item),
+            record: {
+              id: document_number
+            },
+            status: status(_item)
+          }
+        end,
+        source: raw_aleph_response
+      )
+    end
+  end
+
+  private
+
+  def availability(item)
+    case status(item)
+      when :on_shelf, :reshelving then :available
+      else :not_available
+    end
+  end
+
+  def due_date(item)
+    if status(item) == :loaned
+      Date.strptime(item.at_xpath("./status").content[/\d\d\/\d\d\/\d\d/], "%d/%m/%y")
+    end
+  end
+
+  def hold_request_can_be_created(item)
+    if allowed = item.at_xpath("./info[@type='HoldRequest']/@allowed").try(:content).presence
+      allowed == "Y"
+    end
+  end
+
+  def id(item)
+    item.attr("href")[/[^\/]+\Z/][/\A[^?]+/]
+  end
+
+  def expected_date(item)
+    if status(item) == :expected
+      Date.strptime(item.at_xpath("./status").content[/\d\d\/\d\d\/\d\d/], "%d/%m/%y")
+    end
+  end
+
+  def item_status(item)
+    item.at_xpath("./z30/z30-item-status").try(:content)
+  end
+
+  def number_of_hold_requests(item)
+    if queue = item.at_xpath("./queue").try(:content).presence
+      queue[/\A\d+/].try(:to_i) # example: "1 request(s) of 11 items."
+    end || 0
+  end
+
+  def note(item)
+    [
+      item.at_xpath("./z30/z30-description").try(:content),
+      item.at_xpath("./z30/z30-note-opac").try(:content)
+    ]
+    .map(&:presence)
+    .compact
+    .try do |_array|
+      _array.length <= 1 ? _array.first : _array
+    end
+  end
+
+  def status(item)
+    aleph_status = item.at_xpath("./status").try(:content).try(:gsub, /requested/i, "") # remove requested states
+
+    case aleph_status
+      when ""                                     then :on_shelf                  # Exemplar steht im Regal
+      when /on shelf/i                            then :on_shelf                  # Exemplar steht im Regal
+      when /^\d\d\/\d\d\/\d\d/                    then :loaned                    # Exemplar ist entliehen
+      when /Effective due date: \d\d\/\d\d\/\d\d/ then :loaned                    # Exemplar ist entliehen (Rückruf)
+      when /reshelving/i                          then :reshelving                # Exemplar wird zurückgestellt
+      when /on hold/i                             then :on_hold                   # Exemplar ist bereitgestellt
+      when /expected/i                            then :expected                  # Exemplar wird erwartet (es kann dann noch ein Datum geben)
+      when /claimed returned/i                    then :claimed_returned          # Exemplar ist angeblich zurück
+      when /lost/i                                then :lost                      # Exemplar ist verloren gegangen
+      else :unknown
+    end
+  end
+end

data/lib/skala/aleph_adapter/get_user.rb

@@ -0,0 +1,49 @@
+require "skala/adapter/get_user"
+require "skala/get_user_result"
+require_relative "../aleph_adapter"
+
+class Skala::AlephAdapter::GetUser < Skala::Adapter::GetUser
+  def call(username, options = {})
+    user_library = options[:user_library] || @adapter.default_user_library
+    username = username.upcase # ensure that username/id is always upcased for request/result
+
+    raw_aleph_result = @adapter.x_services.post(
+      op: :"bor-info",
+      bor_id: username,
+      library: user_library,
+      cash: "B",
+      hold: "P",
+      loans: "P"
+    )
+
+    if raw_aleph_result.include?("<error>")
+      return nil
+    else
+      fields = Hash.from_xml(raw_aleph_result)
+
+      Skala::GetUserResult.new(
+        cash_balance: cash_balance(fields),
+        email_address: fields["bor_info"]["z304"]["z304_email_address"],
+        expiry_date: Date.strptime(fields["bor_info"]["z305"]["z305_expiry_date"], "%d/%m/%Y"),
+        id: username,
+        first_name: fields["bor_info"]["z303"]["z303_name"].split(",").last.strip,
+        last_name: fields["bor_info"]["z303"]["z303_name"].split(",").first.strip,
+        number_of_hold_requests: [fields["bor_info"]["item_h"]].flatten(1).compact.length,
+        number_of_loans: [fields["bor_info"]["item_l"]].flatten(1).compact.length,
+
+        fields: fields
+      )
+    end
+  end
+
+  private
+
+  def cash_balance(fields)
+    balance = fields["bor_info"]["balance"].to_f
+    sign = fields["bor_info"]["sign"]
+    loans = [fields["bor_info"]["item_l"]].flatten(1).compact
+    current_fines = loans.map { |_loan| _loan["current_fine"].to_f }
+
+    balance * (sign == "D" ? -1 : 1) - current_fines.inject(0.0) { |sum, fine| sum + (fine || 0.0) }
+  end
+end

data/lib/skala/aleph_adapter/get_user_former_loans.rb

@@ -0,0 +1,21 @@
+require "nokogiri"
+require "skala/adapter/get_user_former_loans"
+require_relative "../aleph_adapter"
+require_relative "./get_user_loans"
+
+class Skala::AlephAdapter::GetUserFormerLoans < Skala::Adapter::GetUserFormerLoans
+  def call(username, options = {})
+    get_user_loans_result = get_user_loans(username, type: :history)
+
+    self.class::Result.new(
+      former_loans: get_user_loans_result.loans,
+      source: get_user_loans_result.source
+    )
+  end
+
+  private
+
+  def get_user_loans(*args)
+    adapter.class::GetUserLoans.new(adapter).call(*args)
+  end
+end

data/lib/skala/aleph_adapter/get_user_hold_requests.rb

@@ -0,0 +1,102 @@
+require "nokogiri"
+require "skala/adapter/get_user_hold_requests"
+require_relative "./resolve_user"
+require_relative "../aleph_adapter"
+
+class Skala::AlephAdapter::GetUserHoldRequests < Skala::Adapter::GetUserHoldRequests
+  include parent::ResolveUser
+
+  def call(username, options = {})
+    resolved_user_id = resolve_user(username.upcase)
+
+    raw_aleph_response = adapter.restful_api.patron(resolved_user_id).circulationActions.requests.holds.get(view: :full)
+
+    if raw_aleph_response.include?("<error>")
+      return nil
+    else
+      self.class::Result.new(
+        hold_requests: Nokogiri::XML(raw_aleph_response).xpath("//hold-request").map do |_hold_request|
+          {
+            id: id(_hold_request),
+            deleteable: deleteable?(_hold_request),
+            place_in_queue: place_in_queue(_hold_request),
+            creation_date: creation_date(_hold_request),
+            begin_request_date: begin_request_date(_hold_request),
+            end_request_date: end_request_date(_hold_request),
+            begin_hold_date: begin_hold_date(_hold_request),
+            end_hold_date: end_hold_date(_hold_request),
+            record: {
+              id: record_id(_hold_request)
+            },
+            status: status(_hold_request)
+          }
+        end,
+        source: raw_aleph_response
+      )
+    end
+  end
+
+  private
+
+  def id(hold_request)
+    hold_request.attr("href")[/[^\/]+\Z/][/\A[^?]+/]
+  end
+
+  def creation_date(hold_request)
+    if date = hold_request.at_xpath("./z37/z37-open-date").try(:content)
+      Date.strptime(date, "%Y%m%d")
+    end
+  end
+
+  def deleteable?(hold_request)
+    hold_request.attr("delete") == "Y" && !hold_request.at_xpath(".//status").content.presence.try(:include?, "On hold until")
+  end
+
+  def place_in_queue(hold_request)
+    hold_request.at_xpath(".//status").try(:content).presence.try(:[], /Waiting in position \d+/).try(:[], /\d+/).try(:to_i)
+  end
+
+  def record_id(hold_request)
+    hold_request.at_xpath(".//z13-doc-number").try(:content)
+  end
+
+  def begin_request_date(hold_request)
+    if date = hold_request.at_xpath(".//z37-request-date").try(:content).presence
+      Date.strptime(date, "%Y%m%d")
+    end
+  rescue
+    nil
+  end
+
+  def end_request_date(hold_request)
+    if date = hold_request.at_xpath(".//z37-end-request-date").try(:content).presence
+      Date.strptime(date, "%Y%m%d")
+    end
+  rescue
+    nil
+  end
+
+  def begin_hold_date(hold_request)
+    if date = hold_request.at_xpath(".//z37-hold-date").try(:content).presence
+      Date.strptime(date, "%Y%m%d")
+    end
+  rescue
+    nil
+  end
+
+  def end_hold_date(hold_request)
+    if date = hold_request.at_xpath(".//z37-end-hold-date").try(:content).presence
+      Date.strptime(date, "%Y%m%d")
+    end
+  rescue
+    nil
+  end
+
+  def status(hold_request)
+    case hold_request.at_xpath(".//z37-status").try(:content).presence.try(:upcase)
+      when "WAITING IN QUEUE" then :requested
+      when "S"                then :on_hold
+      when "IN PROCESS"       then :in_process
+    end
+  end
+end

data/lib/skala/aleph_adapter/get_user_inter_library_loans.rb

@@ -0,0 +1,66 @@
+require "nokogiri"
+require "skala/adapter/get_user_inter_library_loans"
+require_relative "./resolve_user"
+require_relative "../aleph_adapter"
+
+class Skala::AlephAdapter::GetUserInterLibraryLoans < Skala::Adapter::GetUserInterLibraryLoans
+  include parent::ResolveUser
+
+  def call(username, options = {})
+    resolved_user_id = resolve_user(username)
+    raw_aleph_response = adapter.restful_api.patron(resolved_user_id).circulationActions.requests.ill.get(view: :brief)
+
+    if raw_aleph_response.include?("<error>")
+      return nil
+    else
+      self.class::Result.new(
+        inter_library_loans: Nokogiri::XML(raw_aleph_response).xpath("//ill-request").map do |_ill_request|
+          {
+            id: id(_ill_request),
+            due_date: due_date(_ill_request),
+            record: {
+              creator: creator(_ill_request),
+              id: record_id(_ill_request),
+              title: title(_ill_request),
+              year_of_publication: year_of_publication(_ill_request)
+            },
+            renewable: renewable(_ill_request)
+          }
+        end,
+        source: raw_aleph_response
+      )
+    end
+  end
+
+  private
+
+  def creator(element)
+    element.at_xpath(".//z13-author").try(:content).presence.try(:split, ";").try(:map, &:strip)
+  end
+
+  def id(element)
+    element.attr("href")[/[^\/]+\Z/][/\A[^?]+/]
+  end
+
+  def due_date(element)
+    if _due_date = element.at_xpath(".//z36-due-date|.//z36h-due-date").try(:content)
+      Date.strptime(_due_date, "%Y%m%d")
+    end
+  end
+
+  def record_id(element)
+    element.at_xpath(".//z410-doc-number").try(:content).presence
+  end
+
+  def renewable(element)
+    element.attr("renew") == "Y"
+  end
+
+  def title(element)
+    element.at_xpath(".//z13-title").try(:content).presence
+  end
+
+  def year_of_publication(element)
+    element.at_xpath(".//z13-year").try(:content).presence
+  end
+end

data/lib/skala/aleph_adapter/get_user_loans.rb

@@ -0,0 +1,93 @@
+require "nokogiri"
+require "skala/adapter/get_user_loans"
+require_relative "./resolve_user"
+require_relative "../aleph_adapter"
+
+class Skala::AlephAdapter::GetUserLoans < Skala::Adapter::GetUserLoans
+  include parent::ResolveUser
+
+  def call(username, options = {})
+    resolved_user_id = resolve_user(username)
+    loans_type = options[:type] == :history ? :history : nil
+    aleph_options = { type: loans_type, view: :full }.compact
+    raw_aleph_response = adapter.restful_api.patron(resolved_user_id).circulationActions.loans.get(aleph_options)
+
+    if raw_aleph_response.include?("<error>")
+      return nil
+    else
+      self.class::Result.new(
+        loans: Nokogiri::XML(raw_aleph_response).xpath("//loan").map do |_loan|
+          {
+            id: id(_loan),
+            due_date: due_date(_loan),
+            fine: fine(_loan),
+            loan_date: loan_date(_loan),
+            record: {
+              id: ils_record_id(_loan),
+              title: title(_loan)
+            },
+            renewable: renewable(_loan),
+            returned_date: returned_date(_loan),
+            signature: signature(_loan)
+          }
+        end,
+        source: raw_aleph_response
+      )
+    end
+  end
+
+  private
+
+  def id(loan)
+    loan.attr("href")[/[^\/]+\Z/][/\A[^?]+/]
+  end
+
+  def due_date(loan)
+    if _due_date = loan.at_xpath(".//z36-due-date|.//z36h-due-date").try(:content)
+      Date.strptime(_due_date, "%Y%m%d")
+    end
+  end
+
+  def loan_date(loan) # only available in full view
+    if _loan_date = loan.at_xpath(".//z36-loan-date|.//z36h-loan-date").try(:content)
+      Date.strptime(_loan_date, "%Y%m%d")
+    end
+  end
+
+  def fine(loan)
+    loan.at_xpath(".//fine").try(:content).presence.try(:to_f)
+  end
+
+  def ils_record_id(element)
+    element.at_xpath("./z13/z13-doc-number").try(:content).presence
+  end
+
+  def renewable(loan)
+    z36_last_renew_date = loan.at_xpath("./z36/z36-last-renew-date").try(:content).presence
+
+    # maybe its present but "00000000" or something else non valid
+    last_renew_date = begin
+      z36_last_renew_date.try do |_date|
+        Date.strptime(_date, "%Y%m%d")
+      end
+    rescue ArgumentError
+      nil
+    end
+
+    loan.attr("renew") == "Y" && (!last_renew_date || last_renew_date < Date.today)
+  end
+
+  def returned_date(loan)
+    if _returned_date = loan.at_xpath(".//z36h-returned-date").try(:content)
+      Date.strptime(_returned_date, "%Y%m%d")
+    end
+  end
+
+  def title(element)
+    element.at_xpath("./z13/z13-title").try(:content).presence
+  end
+
+  def signature(element)
+    element.at_xpath("./z13/z13-call-no").try(:content).presence
+  end
+end