libis-services 0.1.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b0b41e0119e9529ccc88327344d01ce72ff3a8b
+  data.tar.gz: c2dd250a1cd6013b3a7cbd7c9bdf115ce72601f0
+SHA512:
+  metadata.gz: c9549385d9cc8e3d5623b1eaa5538940856e58345725ed8fa4889868e17aacc54866167a38d7e8ce925ae4b34fac6a12c9637c09727d240dddf5fbeb5a44ae82
+  data.tar.gz: 4ca74e43543e1d2ac4608c3e29c33d7fbcda1f00ac0f39cbeafda0acfd94baafb55875898d27a22881bd275cfc3962eb8e7bcde80ac13bba8a9509b57920f0ed

data/.gitignore

@@ -0,0 +1,18 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/.idea/
+
+spec/credentials*
+lib/jar

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in libis-services.gemspec
+gemspec name: 'libis-services', development_group: :test

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Kris Dekeyser
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,36 @@
+[![Gem Version](https://badge.fury.io/rb/libis-services.svg)](http://badge.fury.io/rb/libis-services)
+[![Build Status](https://travis-ci.org/Kris-LIBIS/LIBIS_Services.svg?branch=master)](https://travis-ci.org/Kris-LIBIS/LIBIS_Services)
+[![Coverage Status](https://img.shields.io/coveralls/Kris-LIBIS/LIBIS_Services.svg)](https://coveralls.io/r/Kris-LIBIS/LIBIS_Services)
+[![Dependency Status](https://gemnasium.com/Kris-LIBIS/LIBIS_Services.svg)](https://gemnasium.com/Kris-LIBIS/LIBIS_Services)
+
+# Services
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'Services'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install Services
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/Services/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/lib/libis/services/aleph/search.rb

@@ -0,0 +1,157 @@
+# coding: utf-8
+
+require 'backports/rails/hash'
+require 'libis/tools/xml_document'
+
+require 'libis/services/generic_search'
+
+module Libis
+  module Services
+    module Aleph
+
+      class Search
+        include ::Libis::Services::GenericSearch
+
+        attr_accessor :host
+
+        def find(term, options = {})
+          super
+
+          response = execute_http_query("op=find&code=#{options[:index]}&request=#{options[:term]}&base=#{options[:dbase]}")
+          if response
+            set_number = response['//find/set_number'].to_s
+            num_records = response['//find/no_records'].to_i
+            session_id = response['//find/session-id'].to_s
+            return options.merge id: set_number, num_records: num_records, session_id: session_id, record_pointer: 1
+          end
+          {}
+
+        end
+
+        def each(options)
+
+          return unless ([:record_pointer, :num_records] & options.keys).size == 2
+
+          while options[:record_pointer] <= options[:num_records]
+            next_record(options) { |r| yield r }
+          end
+
+          options
+        end
+
+        def next_record(options = {}, &block)
+
+          return nil unless ([:record_pointer, :num_records, :set_number, :dbase] & options.keys).size == 4
+
+          if options[:record_pointer] <= options[:num_records]
+            response = execute_http_query(
+                'op=present' +
+                    "&set_entry=#{options[:record_pointer]}" +
+                    "&set_number=#{options[:set_number]}" +
+                    "&base=#{options[:dbase]}"
+            )
+
+            if response
+              response.add_node 'search', type: 'opac', host: host, base: options[:dbase]
+              set_entry = response['//set_entry'].to_i
+              if set_entry == options[:record_pointer]
+                add_item_data(response, options[:dbase])
+                block_given? ? yield response : return response
+              end
+            end
+          else
+            puts 'no record found'
+          end
+
+        ensure
+          options[:record_pointer] += 1
+
+        end
+
+        private
+
+        def add_item_data(xml_document, options)
+
+          doc_number = xml_document['//doc_number']
+          response = execute_http_query("op=item-data&base=#{options[:dbase]}&doc-number=#{doc_number}")
+
+          if response
+
+            oai_marc = xml_document.get_node(:oai_marc)
+
+            #noinspection RubyResolve
+            response.get_nodes(:item).each do |r|
+              collection = response.value(:collection, r)
+              location = response.value(:sub-library, r)
+              classification = response.value('call-no-1', r)
+
+              varfield = xml_document.add_node 'varfield', nil, oai_marc, id: '852', i1: ' ', i2: ' '
+
+              xml_document.add_node 'subfield', collection, varfield, label: 'b'
+              xml_document.add_node 'subfield', location, varfield, label: 'c'
+              xml_document.add_node 'subfield', classification.gsub('$$h', ''), varfield, label: 'h'
+
+            end
+          end
+        end
+
+
+        def execute_http_query(data)
+          raise Exception, 'No host set' if host.nil? || host.size == 0
+
+          redo_count = 10
+          xml_document = nil
+
+          redo_search = false
+
+          begin
+            redo_search = false
+
+            begin
+              redo_count = redo_count - 1
+              sleep_time = 0.1 # in minutes
+
+              response = Net::HTTP.fetch(host, :data => data, :action => :post)
+
+              if response.is_a?(Net::HTTPOK)
+                xml_document = Libis::Tools::XmlDocument.parse(response.body)
+                error = xml_document['//error']
+
+                unless xml_document && error.nil?
+                  unless error == 'empty set'
+                    puts
+                    puts "----------> Error searching for #{data} --> '#{error}'"
+                    puts
+                  end
+                  if error =~ /license/
+                    redo_search = true
+                  end
+                end
+              else
+                puts response.error!
+              end
+            rescue Exception => ex
+              sleep_time = 0.5
+              if ex.message =~ /503 "Service Temporarily Unavailable"/
+                sleep_time = 30
+                Libis::Tools::Config.logger.warn "OPAC Service temporarily unavailable - retrying after #{sleep_time} minutes"
+              else
+                Libis::Tools::Config.logger.error "Problem with OPAC: '#{ex.message}' - retrying after #{sleep_time} minutes"
+                ex.backtrace.each { |x| Libis::Tools::Config.error "#{x}" }
+              end
+              redo_search = true
+            end
+
+            sleep sleep_time * 60 if redo_search
+
+          end until redo_search == false or redo_count < 0
+
+          xml_document
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/services/alma/web_service.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+require 'libis-tools'
+require 'libis/services/service_error'
+require 'libis/services/rest_client'
+
+module Libis
+  module Services
+    module Alma
+
+      class WebService
+        include ::Libis::Services::RestClient
+
+        def initialize(url = 'https://api-eu.hosted.exlibrisgroup.com/almaws/v1/bibs')
+          configure(url)
+        end
+
+        def get_marc(alma_id, apikey = nil)
+          apikey ||= case alma_id
+                      when /1480$/
+                        'l7xx8879c82a7d7b453a887a6e6dca8300fd'
+                      else
+                        raise Libis::Services::ServiceError, "No Alma API key available for '#{alma_id}'"
+                    end
+          get alma_id, apikey: apikey
+        end
+
+        protected
+
+        def result_parser(response)
+          Libis::Tools::XmlDocument.parse(response)
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/services/collective_access/cataloguing.rb

@@ -0,0 +1,48 @@
+# coding: utf-8
+
+require_relative 'connector'
+
+module Libis
+  module Services
+    module CollectiveAccess
+
+      class Cataloguing < Connector
+
+        def initialize(host = nil)
+          super 'Cataloguing', host
+        end
+
+        def add_item(fields, type = nil)
+          type ||= 'ca_objects'
+          r, a = soap_encode fields
+          request :add, type: type, fieldInfo: r, :attributes! => {fieldInfo: a}
+        end
+
+        def add_attributes(item, data, type = nil)
+          type ||= 'ca_objects'
+          r, a = soap_encode data
+          request :getAttributesByElement, type: type, item_id: item, attribute_code_or_id: attribute.to_s, attribute_list_array: r, :attributes! => {attribute_list_array: a}
+
+        end
+
+        def add_attribute(item, attribute, data, type = nil)
+          type ||= 'ca_objects'
+          r, a = soap_encode data
+          request :addAttribute, type: type, item_id: item, attribute_code_or_id: attribute.to_s, attribute_data_array: r, :attributes! => {attribute_data_array: a}
+        end
+
+        def remove(item, type = nil)
+          type ||= 'ca_objects'
+          request :remove, type: type, item_id: item
+        end
+
+        def remove_attributes(item, type = nil)
+          type ||= 'ca_objects'
+          request :removeAllAttributes, type: type, item_id: item
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/services/collective_access/connector.rb

@@ -0,0 +1,151 @@
+# coding: utf-8
+
+require 'libis/services/soap_client'
+
+module Libis
+  module Services
+    module CollectiveAccess
+
+      #noinspection RubyStringKeysInHashInspection
+      class Connector
+        include Libis::Services::SoapClient
+
+        attr_accessor :type_cast
+
+        def initialize(service, host = nil)
+          @type_cast = true
+          @host = host || 'http://crkc.be.halotest.cc.kuleuven.be/ca_crkc'
+          @service = service
+          configure "#{@host}/service.php/#{@service.downcase}/#{@service}/soapWSDL?wsdl",
+                    convert_request_keys_to: :none,
+                    # convert_response_tags_to: lambda {
+                    #     |tag| %w(Envelope Body).include?(tag) ? tag.snakecase.to_sym : tag.to_sym
+                    # },
+                    strip_namespaces: true
+        end
+
+        def authenticate(name = nil, password = nil)
+          name ||= 'administrator'
+          password ||= 'administrator'
+          result = request :auth, username: name, password: password
+          result.to_i == 1
+        end
+
+        def deauthenticate
+          request :deauthenticate
+        end
+
+        protected
+
+        def result_parser(response)
+          result = response.hash
+          type_caster(result.first[1][result.first[1][:result].snakecase.to_sym])
+        end
+
+        def type_caster(result)
+          return result unless @type_cast
+          return result unless result.is_a? Hash
+
+          r = result
+
+          case r[:'@xsi:type']
+            when 'enc:Array'
+              elements = result[:item]
+              if elements.is_a? Array
+                r = Array.new
+                elements.each { |i| r << type_caster(i) }
+              else
+                r = type_caster(result[:item])
+              end
+
+            when 'ns2:Map'
+              r = {}
+              elements = result[:item]
+              unless elements.is_a? Array
+                elements = Array.new
+                elements << result[:item]
+              end
+
+              elements.each { |i|
+                key = i[:key]
+                value = i[:value]
+                value = type_caster(value)
+                r[key] = value
+              }
+            else
+            #do nothing
+          end
+          r
+        end
+
+        NS_ATTR_ENC = {'xmlns:enc' => 'http://schemas.xmlsoap.org/soap/encoding/'}
+        NS_ATTR_NS2 = {'xmlns:ns2' => 'http://xml.apache.org/xml-soap'}
+
+        def soap_encode(data)
+          result = data
+          attributes = nil
+          case data
+            when Array
+              i = data.size
+              t = type_string data[0]
+              attributes = {'xsi:type' => 'enc:Array'}
+              if t
+                attributes['enc:arrayType'] = "#{t}[#{i}]"
+              else
+                attributes['enc:arraySize'] = i
+              end
+              attributes.merge! NS_ATTR_ENC
+              if t =~ /^ns2:/
+                attributes.merge! NS_ATTR_NS2
+              end
+              result = Array.new
+              data.each { |x|
+                r, a = soap_encode x
+                i = {item: r}
+                i[:attributes!] = {item: a} if a
+                result << i
+              }
+            when Hash
+              attributes = {'xsi:type' => 'ns2:Map'}.merge NS_ATTR_NS2
+              result = {item: Array.new}
+              data.each { |k, v|
+                rk, ak = soap_encode k.to_s
+                rv, av = soap_encode v
+                i = {key: rk, value: rv}
+                i[:attributes!] = {}
+                i[:attributes!][:key] = ak if ak
+                i[:attributes!][:value] = av if av
+                result[:item] << i
+              }
+            else
+              t = type_string data
+              if t
+                attributes = {'xsi:type' => t}
+                attributes.merge! NS_ATTR_ENC if t =~ /^enc:/
+                attributes.merge! NS_ATTR_NS2 if t =~ /^ns2:/
+              end
+          end
+          return result, attributes
+        end
+
+        def type_string(data)
+          return nil if data.nil?
+          case data
+            when Array
+              'enc:Array'
+            when Hash
+              'ns2:Map'
+            when String
+              'xsd:string'
+            when Integer
+              'xsd:int'
+            else
+              'xsd:string'
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/services/collective_access/item_info.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+
+require_relative 'connector'
+
+module Libis
+  module Services
+    module CollectiveAccess
+
+      class ItemInfo < Connector
+
+        def initialize(host = nil)
+          super 'ItemInfo', host
+        end
+
+        def get_attributes(item, type = nil)
+          type ||= 'ca_objects'
+          request :getAttributes, type: type, item_id: item.to_s
+        end
+
+        def get_attribute(item, attribute, type = nil)
+          type ||= 'ca_objects'
+          request :getAttributesByElement, type: type, item_id: item.to_s, attribute_code_or_id: attribute.to_s
+        end
+
+        def get_items(item_list, bundle, type = nil)
+          type ||= 'ca_objects'
+          r1, a1 = soap_encode item_list
+          r2, a2 = soap_encode bundle
+          request :get, type: type, item_ids: r1, bundles: r2, :attributes! => {item_ids: a1, bundles: a2}
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/services/collective_access/search.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+
+require 'libis/services/generic_search'
+
+require_relative 'connector'
+
+module Libis
+  module Services
+    module CollectiveAccess
+
+      class Search < Connector
+        include ::Libis::Services::GenericSearch
+
+        def initialize(host = nil)
+          super 'Search', host
+        end
+
+        def query(query, options = {})
+          request :querySoap, type: (options[:index] || 'ca_objects'), query: query
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/services/collective_access/service.rb

@@ -0,0 +1,80 @@
+# coding: utf-8
+
+require_relative 'search'
+require_relative 'item_info'
+require_relative 'cataloguing'
+
+module Libis
+  module Services
+    module CollectiveAccess
+
+      class Service
+
+        attr_reader :search, :info, :cata
+
+        def initialize(host = nil)
+          @search = ::Libis::Services::CollectiveAccess::Search.new host
+          @info = ::Libis::Services::CollectiveAccess::ItemInfo.new host
+          @cata = ::Libis::Services::CollectiveAccess::Cataloguing.new host
+        end
+
+        def authenticate(name = nil, password = nil)
+          result = @search.authenticate name, password
+          result &&= @info.authenticate name, password
+          result && @cata.authenticate(name, password)
+        end
+
+        def deauthenticate
+          @search.deauthenticate
+          @info.deauthenticate
+          @cata.deauthenticate
+        end
+
+        def add_object(label)
+          @cata.add_item idno: label, type_id: 21
+        end
+
+        def search_object(attributes = {})
+          query = attributes.delete :query || ''
+          query = attributes.inject(query) { |q, (k, v)|
+            q << ' AND ' unless q.empty?
+            q << k << ':' if k
+            v = "\"#{v}\"" if v.is_a?(String) and !v.include? '"'
+            q << v
+          }
+          result = @search.query query
+          return nil unless result && result.is_a?(Hash) && !result.empty?
+          result.first[0]
+        end
+
+        def get_object(label)
+          search_object query: "\"#{label}\""
+        end
+
+        def delete_object(object)
+          @cata.remove object
+        end
+
+        def add_attribute(object, attribute, value)
+          @cata.add_attribute object, attribute.to_s, {attribute.to_sym => value}
+        end
+
+        def get_attribute(object, attribute)
+          result = @info.get_attribute object, attribute
+          result = [result] unless result.is_a? Array
+          result
+        end
+
+        def delete_attribute(_, _) #object, attribute)
+
+        end
+
+        def delete_attributes(object)
+          @cata.remove_attributes object
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/services/collective_access.rb

@@ -0,0 +1 @@
+require 'libis/services/collective_access/service'