median 0.0.1

data/lib/median/aleph/item.rb

@@ -0,0 +1,34 @@
+class Median::Aleph::Item
+  include Median::XmlSupport
+
+  field :sub_library_code,   :xpath => './z30-sub-library-code'
+  field :sub_library_string, :xpath => './z30/z30-sub-library'
+  field :collection,         :xpath => './z30/z30-collection'
+  field :signature,          :xpath => './z30/z30-call-no'
+  field :barcode,            :xpath => './z30/z30-barcode'
+  field :status_code,        :xpath => './z30-item-status-code'
+  field :status_string,      :xpath => './z30/z30-item-status'
+  field :material,           :xpath => './z30/z30-material'
+  field :loan_date,          :xpath => './status', :process => :format_date
+  field :no_of_holds,        :xpath => './queue',  :process => :get_no_of_holds
+
+  private
+
+  def format_date(value)
+    begin
+      Date.strptime(value, '%d/%m/%y')
+    rescue
+      nil
+    end
+  end
+
+  def get_no_of_holds(value)
+    begin
+      matches = value.match(/([0-9]+).+([0-9]+)/)
+      matches[1].to_i
+    rescue
+      0
+    end
+  end
+
+end

data/lib/median/aleph/loan.rb

@@ -0,0 +1,59 @@
+module Median::Aleph
+  module Loan
+
+    def get_loans(patron_id, options = {})
+      options = options.reverse_merge(history: false)
+      loans = []
+
+      # load loans
+      url = "#{Median.config.aleph_rest_service_base_url}/patron/#{patron_id}/circulationActions/loans"
+      xml = options[:history] ?
+        get_url(url, view: 'brief', type: 'history', no_loans: 250) :
+        get_url(url, view: 'brief')
+
+      # parse result
+      xml.xpath('//loan').each do |loan_xml|
+        loan = OpenStruct.new
+        loan.id        = loan_xml.attribute('href').try(:content).try(:split, '/').try(:last)
+        loan.can_renew = (loan_xml.attribute('renew').try(:content).try(:upcase) == 'Y') ? true : false
+        loan.author    = loan_xml.at_xpath('z13-author').try(:content)
+        loan.title     = loan_xml.at_xpath('z13-title').try(:content)
+        loan.year      = loan_xml.at_xpath('z13-year').try(:content)
+        return_date    = loan_xml.at_xpath('z36h-returned-date').try(:content)
+        due_date       = loan_xml.at_xpath('z36-due-date').try(:content)
+        loan.returned  = return_date.present? ? Date.strptime(return_date, '%Y%m%d') : nil
+        loan.due       = due_date.present? ? Date.strptime(due_date, '%Y%m%d') : nil
+        loans << loan
+      end
+
+      # sort by due date ascending
+      loans.sort{|x,y| x.due <=> y.due }
+
+      # return
+      loans
+    end
+
+    def renew_loan(patron_id, loan_id)
+      xml = post_url("#{Median.config.aleph_rest_service_base_url}/patron/#{patron_id}/circulationActions/loans/#{loan_id}")
+
+      result_code = xml.at_xpath('//reply-code').try(:content).to_i
+      if result_code == 0 # no error
+        return true
+      end
+
+      return false
+    end
+
+    def renew_loans(patron_id)
+      xml = post_url("#{Median.config.aleph_rest_service_base_url}/patron/#{patron_id}/circulationActions/loans")
+
+      result_code = xml.at_xpath('//reply-code').try(:content).to_i
+      if result_code == 0 # no error
+        return true
+      end
+
+      return false
+    end
+
+  end
+end

data/lib/median/aleph/patron.rb

@@ -0,0 +1,110 @@
+module Median::Aleph
+  module Patron
+
+    def change_patron_email(patron_id, email)
+      data01 = change_patron_email!(patron_id, email, "01")
+      data02 = change_patron_email!(patron_id, email, "02")
+
+      if bor_update_successfull?(data02)
+        return true
+      else
+        return false
+      end
+    end
+
+
+    def change_patron_password(patron_id, current_password, new_password)
+      # first (re)authenticate
+      if AlephApi.authenticate(patron_id, current_password)
+        # after successfull authentication, write the new password
+        data = post_url(Median.config.aleph_x_service_base_url,
+          op: 'update_bor',
+          update_flag: 'Y',
+          library: Median.config.aleph_user_library,
+          xml_full_req: <<-XML
+            <?xml version="1.0"?>
+            <p-file-20>
+              <patron-record>
+                <z303>
+                  <match-id-type>01</match-id-type>
+                  <match-id>#{patron_id}</match-id>
+                  <record-action>X</record-action>
+                </z303>
+                <z308>
+                  <record-action>U</record-action>
+                  <z308-key-type>01</z308-key-type>
+                  <z308-key-data>#{patron_id}</z308-key-data>
+                  <z308-verification>#{new_password}</z308-verification>
+                </z308>
+              </patron-record>
+            </p-file-20>
+          XML
+        )
+
+        if bor_update_successfull?(data)
+          return true
+        else
+          return false
+        end
+      else
+        return false
+      end
+    end
+
+    private
+
+    def change_patron_email!(patron_id, email, type)
+      data = post_url(Median.config.aleph_x_service_base_url,
+        op: 'update_bor',
+        update_flag: 'Y',
+        library: Median.config.aleph_user_library,
+        xml_full_req: <<-XML
+          <?xml version="1.0"?>
+          <p-file-20>
+            <patron-record>
+              <z303>
+                <match-id-type>01</match-id-type>
+                <match-id>#{patron_id}</match-id>
+                <record-action>X</record-action>
+              </z303>
+              <z304>
+                <record-action>U</record-action>
+                <z304-id>#{patron_id}</z304-id>
+                <z304-address-type>#{type}</z304-address-type>
+                <z304-sequence>01</z304-sequence>
+                <z304-email-address>#{email}</z304-email-address>
+              </z304>
+            </patron-record>
+          </p-file-20>
+        XML
+      )
+
+      return data
+    end
+
+    # Checks if the call was successfull. We face a problem here. X-Service Api
+    # was created by morons, so we need a dirty hack to distinguish between
+    # a successfull result and an error, because the message is always given
+    # inside an error-tag. E.g.
+    #
+    # An error:
+    #   <update-bor>
+    #     <patron-id>PB29096</patron-id>
+    #     <error>Cannot update / delete z304. No match found for ID: PB29096.</error>
+    #     ...
+    #   </update-bor>
+    #
+    # A success:
+    #   <update-bor>
+    #     <patron-id>PA06003114</patron-id>
+    #     <error>Succeeded to REWRITE table z308. cur-id PA06003114.</error>
+    #     ...
+    #   </update-bor>
+    #
+    def bor_update_successfull?(data)
+      return (data.at_xpath('/update-bor/patron-id') and
+        data.at_xpath('/update-bor/error').try(:content).try(:match, /Succ/i))
+    end
+
+  end
+end

data/lib/median/aleph/search.rb

@@ -0,0 +1,11 @@
+module Median::Aleph
+  module Search
+
+    def find_items(record_id, patron_id = nil)
+      url = "#{Median.config.aleph_rest_service_base_url}/record/#{record_id}/items"
+      xml = get_url(url, view: 'full')
+      xml.xpath('//items/item').collect { |xml| Item.new(xml) }
+    end
+
+  end
+end

data/lib/median/aleph/utils.rb

@@ -0,0 +1,82 @@
+module Median::Aleph
+  module Utils
+
+    def get_url(url, data = {})
+      begin
+        uri       = get_uri(url)
+        uri.query = URI.encode_www_form(data)
+        http      = get_http_connection(uri)
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request.set_form_data(data)
+
+        response = http.request(request)
+        Nokogiri::XML(response.body)
+      rescue Exception => e
+        raise Median::ConnectionError.new(e)
+      end
+    end
+
+    def post_url(url, data = {})
+      begin
+        uri  = get_uri(url)
+        http = get_http_connection(uri)
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.set_form_data(data)
+
+        response = http.request(request)
+        Nokogiri::XML(response.body)
+      rescue Exception => e
+        raise Median::ConnectionError.new(e)
+      end
+    end
+
+    def delete_url(url, data = {})
+      begin
+        uri       = get_uri(url)
+        uri.query = URI.encode_www_form(data)
+        http      = get_http_connection(uri)
+
+        request = Net::HTTP::Delete.new(uri.request_uri)
+        request.set_form_data(data)
+
+        response = http.request(request)
+        Nokogiri::XML(response.body)
+      rescue Exception => e
+        raise Median::ConnectionError.new(e)
+      end
+    end
+
+    def put_url(url, data = {})
+      begin
+        uri       = get_uri(url)
+        uri.query = URI.encode_www_form(data)
+        http      = get_http_connection(uri)
+
+        request = Net::HTTP::Put.new(uri.request_uri)
+        request.set_form_data(data)
+
+        response = http.request(request)
+        Nokogiri::XML(response.body)
+      rescue Exception => e
+        raise Median::ConnectionError.new(e)
+      end
+    end
+
+    private
+
+    def get_uri(url, params = {})
+      url = "#{url}?#{params.collect{"#{k.to_s}=#{v.to_s}"}.join('&')}" if params
+      URI.parse(URI.escape(url))
+    end
+
+    def get_http_connection(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == 'https')
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      return http
+    end
+
+  end
+end

data/lib/median/primo.rb

@@ -0,0 +1,9 @@
+require 'median/primo/search'
+require 'median/primo/search_request'
+require 'median/primo/search_result'
+require 'median/primo/record'
+require 'median/primo/facet'
+
+module Median::Primo
+  extend Search
+end

data/lib/median/primo/facet.rb

@@ -0,0 +1,27 @@
+class Median::Primo::Facet
+  include Median::XmlSupport
+
+  field :name, :xpath => '.', :attribute => 'NAME'
+
+  def initialize(xml)
+    super(xml)
+    @values = xml.xpath(".//FACET_VALUES").collect{ |xml| FacetValue.new(xml) }
+
+    if name == 'creationdate'
+      @values.sort!{ |x, y| y.key <=> x.key }
+    else
+      @values.sort!{ |x, y| y.count <=> x.count }
+    end
+  end
+
+  attr_reader :values
+
+  private
+
+  class FacetValue
+    include Median::XmlSupport
+
+    field :key,   :xpath => '.', :attribute => 'KEY'
+    field :count, :xpath => '.', :attribute => 'VALUE', :process => proc{ |v| v.to_i }
+  end
+end

data/lib/median/primo/record.rb

@@ -0,0 +1,115 @@
+class Median::Primo::Record
+  include Median::XmlSupport
+
+  field :rank,               xpath: '.', :attribute => 'RANK', process: proc{|v| v.to_f}
+  field :id,                 xpath: './/record/search/recordid'
+  field :ils_id,             xpath: './/record/control/ilsapiid'
+  field :source_ids,         xpath: './/record/control/sourceid', multiple: true
+  field :type,               xpath: './/record/display/type'
+  field :title,              xpath: './/record/display/title'
+  field :authors,            xpath: './/record/display/creator', multiple: true, autosplit: ';'
+  field :contributors,       xpath: './/record/display/contributor', multiple: true,  autosplit: ';'
+  field :publisher,          xpath: './/record/display/publisher'
+  field :ispartof,           xpath: './/record/display/ispartof'
+  field :creationdate,       xpath: './/record/display/creationdate'
+  field :edition,            xpath: './/record/display/edition'
+  field :versions,           xpath: './/record/display/version', process: proc{|v| v.to_i}, default: 1
+  field :subjects,           xpath: './/record/search/subject', multiple: true
+  field :item_format,        xpath: './/record/display/format'
+  field :languages,          xpath: './/record/display/language', multiple: true, autosplit: ';'
+  field :identifier,         xpath: './/record/display/identifier'
+  field :relations,          xpath: './/record/display/relation', multiple: true
+  field :notations,          xpath: './/record/search/lsr15', multiple: true, autosplit: ';'
+  field :superorder,         xpath: './/record/search/lsr01'
+  field :suborder,           xpath: './/record/search/lsr02'
+  field :frbrgroupid,        xpath: './/record/facets/frbrgroupid'
+  field :description,        xpath: './/record/display/description'
+  field :delivery_category,  xpath: './/record/delivery/delcategory', process: proc{|v| v.downcase}
+  field :fulltext_available, xpath: './/record/delivery/fulltext', process: proc{|v| v.downcase != 'no_fulltext'}, default: true
+
+  attr_reader :links
+
+  def initialize(xml)
+    super(xml)
+    @links = Links.new(xml)
+  end
+
+  def dedub?
+    self.id.present? ? self.id.downcase.start_with?('dedupmrg') : false
+  end
+
+  def local_resource?
+    !online_resource?
+  end
+
+  def online_resource?
+    online_resource_categories = ['online_resource', 'online resource', 'remote search resource', 'sfx resource']
+    online_resource_categories.include?(self.delivery_category)
+  end
+
+  def versions?
+    versions > 1
+  end
+
+  def series?
+    type.try(:downcase) == 'serie' or delivery_category == 'structural metadata'
+  end
+
+  private
+
+  class Links
+    include Median::XmlSupport
+
+    field :openurl,         xpath: './LINKS/openurl', process: :force_sfx_menu_language
+    field :backlink,        xpath: './LINKS/backlink'
+    field :thumbnail,       xpath: './LINKS/thumbnail'
+    field :resource_links,  xpath: './LINKS/linktorsrc', multiple: true
+
+    def filtered_resource_links
+      filter_ezb_links(self.resource_links)
+    end
+
+    def default_resource_link
+      filtered_resource_links.first
+    end
+
+    def resource_link?
+      self.resource_links.present?
+    end
+
+
+    private
+
+    def filter_ezb_links(links)
+      ezb_link = get_ezb_link(links)
+      ezb_link.present? ? [ezb_link] : links
+    end
+
+    def get_ezb_link(links)
+      links.each do |link|
+        return link if link.include? 'uni-regensburg.de/ezeit'
+      end
+      nil
+    end
+
+    def force_sfx_menu_language(openurl)
+      openurl.gsub(/req\.language=.+&/, '') # remove the language setting to force thedefault
+    end
+  end
+
+  #
+  # GetIt links are broken in the SOAP API. The links always point to the first result.
+  #
+  #class GetItLinks < Array
+  #  def initialize(xml)
+  #    super()
+  #    nodes = xml.xpath('./GETIT')
+  #    nodes.each do |node|
+  #      #puts node.inspect
+  #      #self << {getit1: node.attribute('GetIt1').try(:value), getit2: node.attribute('GetIt2').try(:value)}
+  #      #puts self
+  #    end
+  #  end
+  #end
+
+end