libis-services 0.0.2

data/lib/libis/services/extend/http_fetch.rb

@@ -0,0 +1,63 @@
+# coding: utf-8
+
+require 'net/http'
+require 'set'
+
+class Net::HTTPResponse
+  #noinspection RubyResolve
+  attr_accessor :final_uri
+end
+
+
+module Net
+
+  begin
+    require 'net/https'
+    HTTPS_SUPPORTED = true
+  rescue LoadError
+  end
+
+  class HTTP
+    def self.fetch(uri, args={}.freeze, &before_fetching)
+      uri = URI.parse(uri) unless uri.is_a? URI
+      proxy_host    = args[:proxy_host]
+      proxy_port    = args[:proxy_port] || 80
+      action        = args[:action] || :get
+      data          = args[:data]
+      max_redirects = args[:max_redirects] || 10
+
+      proxy_class   = Proxy(proxy_host, proxy_port)
+      #noinspection RubyArgCount
+      request       = proxy_class.new(uri.host, uri.port)
+
+      request.use_ssl = true if HTTPS_SUPPORTED && uri.scheme.eql?('https')
+
+      yield request if block_given?
+#debugger
+      response = request.send(action, uri.path, data)
+
+      urls_seen = args[:_url_seen] || Set.new
+
+      case response
+      when Net::HTTPRedirection
+        if urls_seen.size < max_redirects && response['Location']
+          urls_seen << uri
+          new_uri = URI.parse(response['Location'])
+          if urls_seen.member? new_uri
+            nil
+          else
+            new_args = args.dup
+            new_args[:_urls_seen] = urls_seen
+
+            response = HTTP.fetch(new_uri, new_args, &before_fetching)
+          end
+        end
+      when Net::HTTPSuccess
+        response.final_uri = uri
+      else
+        response.error!
+      end
+      return response
+    end
+  end
+end

data/lib/libis/services/generic_search.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+require 'libis/services/extend/http_fetch'
+
+module Libis
+  module Services
+
+    module GenericSearch
+
+      #noinspection RubyResolve
+      attr_accessor :host
+      #noinspection RubyResolve
+      attr_reader :query, :term, :index, :base
+      #noinspection RubyResolve
+      attr_reader :num_records, :set_number
+      #noinspection RubyResolve
+      attr_reader :record_pointer, :session_id
+
+      def query(query, options = {})
+        raise RuntimeError, 'to be implemented'
+      end
+
+      def find(term, options = {})
+        query(term, options)
+      end
+
+      def each(options = {}, &block)
+        raise RuntimeError, 'to be implemented'
+      end
+
+      def next_record(options = {}, &block)
+        raise RuntimeError, 'to be implemented'
+      end
+
+    end
+
+  end
+end

data/lib/libis/services/http_error.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Libis
+  module Services
+
+    class HttpError < Exception
+      attr_accessor :code, :header, :body
+
+      def initialize(error)
+        @code = error[:code]
+        @header = error[:header]
+        @body = error[:body]
+      end
+
+      def message
+        code.to_s
+      end
+    end
+
+  end
+end

data/lib/libis/services/oracle_client.rb

@@ -0,0 +1,47 @@
+module Libis
+  module Services
+
+    class OracleClient
+
+      def initialize(database, user, password)
+        @database = database
+        @user = user
+        @password = password
+      end
+
+      def call(procedure, parameters = [])
+        params = ''
+        params = "'" + parameters.join("','") + "'" if parameters and parameters.size > 0
+        system "echo \"call #{procedure}(#{params});\" | sqlplus -S #{@user}/#{@password}@#{@database}"
+      end
+
+      def run(script, parameters = [])
+        params = ''
+        params = "\"" + parameters.join("\" \"") + "\"" if parameters and parameters.size > 0
+        process_result `sqlplus -S #{@user}/#{@password}@#{@database} @#{script} #{params}`
+      end
+
+      def execute(sql)
+        process_result `echo \"#{sql}\" | sqlplus -S #{@user}/#{@password}@#{@database}`
+      end
+
+      private
+
+      def process_result(log)
+        log.gsub!(/\n\n/, "\n")
+        rows_created = 0
+        log.match(/^(\d+) rows? created.$/) { |m| rows_created += m[1] }
+        rows_deleted = 0
+        log.match(/^(\d+) rows? deleted.$/) { |m| rows_deleted += m[1] }
+        rows_updated = 0
+        log.match(/^(\d+) rows? updated.$/) { |m| rows_updated += m[1] }
+        errors = Hash.new(0)
+        error_count = 0
+        log.match(/\nERROR .*\n([^\n]*)\n/) { |m| errors[m[1]] += 1; error_count += 1 }
+        {created: rows_created, updated: rows_updated, deleted: rows_deleted, errors: error_count, error_detail: errors}
+      end
+
+    end
+
+  end
+end

data/lib/libis/services/primo.rb

@@ -0,0 +1,2 @@
+require_relative 'primo/search'
+require_relative 'primo/limo'

data/lib/libis/services/primo/limo.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+require 'libis-tools'
+
+require 'libis/services/rest_client'
+
+module Libis
+  module Services
+    module Primo
+
+      class Limo
+        include ::Libis::Services::RestClient
+
+        def initialize(url = 'http://limo.libis.be')
+          configure(url)
+        end
+
+        def get_marc(alma_id)
+          get 'primo_library/libweb/jqprimo/helpers/record_helper.jsp', id: "#{alma_id}.xml"
+        end
+
+        def get_pnx(alma_id)
+          get 'primo_library/libweb/jqprimo/helpers/record_helper.jsp', id: "#{alma_id}.pnx"
+        end
+
+        protected
+
+        def result_parser(response)
+          Libis::Tools::XmlDocument.parse(response)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# coding: utf-8
+require 'json'
+
+require 'libis/services/rest_client'
+require 'libis/services/generic_search'
+
+module Libis
+  module Services
+    module Primo
+
+      class Search
+        include ::Libis::Services::RestClient
+        include ::Libis::Services::GenericSearch
+
+        def initialize(url = 'https://services.libis.be')
+          configure(url)
+        end
+
+        def query(query, options = {})
+          index = options.delete(:index) || 'any'
+          get 'search', {query: "#{index}:#{query}"}.merge(options)
+        end
+
+        def find(term, options = {})
+          max_count = options.delete(:max_count) || 100
+          result = []
+          while result.size < max_count
+            reply = query(term, options.merge(from: result.size + 1))
+            max_count = [max_count, reply[:count]].min
+            reply[:data].each do |record|
+              next unless result.size < max_count
+              result << record[:display]
+            end
+          end
+          result
+        end
+
+        protected
+
+        def result_parser(response)
+          JSON.parse(response, symbolize_names: true)
+        end
+      end
+    end
+  end
+end

data/lib/libis/services/rest_client.rb

@@ -0,0 +1,66 @@
+# coding: utf-8
+
+require 'rest-client'
+require 'nori'
+require 'json'
+require 'gyoku'
+
+module Libis
+  module Services
+
+    module RestClient
+      attr_reader :client
+
+      def configure(url, options = {})
+        @client = ::RestClient::Resource.new(url, options)
+      end
+
+      def get(path, params = {}, headers = {}, &block)
+        response = client[path].get({params: params}.merge headers, &block)
+        parse_result response, &block
+      rescue ::RestClient::Exception => e
+        return {error_type: e.class.name, error_name: e.message, response: parse_result(e.response, &block)}
+      end
+
+      def post_url(path, params = {}, headers = {}, &block)
+        response = client[path].post({params: params}.merge headers, &block)
+        parse_result response, &block
+      rescue ::RestClient::Exception => e
+        return {error_type: e.class.name, error_name: e.message, response: parse_result(e.response, &block)}
+      end
+
+      def post_data(path, payload, headers = {}, &block)
+        response = client[path].post(payload, headers, &block)
+        parse_result response, &block
+      rescue ::RestClient::Exception => e
+        return {error_type: e.class.name, error_name: e.message, response: parse_result(e.response, &block)}
+      end
+
+      def put_url(path, params = {}, headers = {}, &block)
+        response = client[path].put({params: params}.merge headers, &block)
+        parse_result response, &block
+      rescue ::RestClient::Exception => e
+        return {error_type: e.class.name, error_name: e.message, response: parse_result(e.response, &block)}
+      end
+
+      def put_data(path, payload, headers = {}, &block)
+        response = client[path].put(payload, headers, &block)
+        parse_result response, &block
+      rescue ::RestClient::Exception => e
+        return {error_type: e.class.name, error_name: e.message, response: parse_result(e.response, &block)}
+      end
+
+      protected
+
+      def parse_result(response)
+        block_given? ? yield(response) : result_parser(response)
+      end
+
+      def result_parser(response)
+        response
+      end
+
+    end
+
+  end
+end

data/lib/libis/services/rosetta.rb

@@ -0,0 +1 @@
+require_relative 'rosetta/service'

data/lib/libis/services/rosetta/client.rb

@@ -0,0 +1,107 @@
+# coding: utf-8
+
+require 'libis/services/soap_client'
+require 'libis/tools/extend/hash'
+require 'libis/tools/config'
+require 'libis/tools/logger'
+
+require 'awesome_print'
+
+module Libis
+  module Services
+    module Rosetta
+
+      class Client
+        include ::Libis::Services::SoapClient
+        include ::Libis::Tools::Logger
+
+        def initialize(section, service, options = {})
+          opts = {strip_namespaces: true, logger: ::Libis::Tools::Config.logger}.merge options
+          base_url = opts.delete(:url) || 'http://depot.lias.be'
+          configure "#{base_url}/dpsws/#{section}/#{service}?wsdl", opts
+        end
+
+        def pds_handle=(handle)
+          @pds_handle = handle
+        end
+
+        def get_heart_bit
+          request :get_heart_bit
+        end
+
+        protected
+
+        def call_raw(operation, args = {})
+          data = request operation.to_s.to_sym, args
+
+          # remove wrapper
+          data = data["#{operation}_response".to_sym]
+          data.delete(:'@xmlns:ns1')
+
+          # drill down the returned Hash
+          data = data.first.last while data.is_a?(Hash) && 1 == data.size
+
+          data
+        end
+
+        def call(operation, args = {})
+          # upstream call
+          data = call_raw(operation, args)
+
+          # try to parse as XML
+          if data.is_a?(String)
+            xml_data = Libis::Tools::XmlDocument.parse(data).to_hash(
+                empty_tag_value: nil,
+                delete_namespace_attributes: true,
+                strip_namespaces: true,
+                convert_tags_to: lambda { |tag| tag.to_sym }
+            )
+            data = xml_data unless xml_data.empty?
+          end
+
+          return data unless data.is_a?(Hash)
+
+          # drill down
+          data = data.first.last if 1 == data.size
+
+          return data unless data.is_a?(Hash)
+
+          # check for errors
+          if data.delete :is_error
+            error data.delete :error_description
+            return nil
+          end
+
+          # only delete if there is other info. ProducerService isUserExists uses this field as return value.
+          data.delete :error_description if data.size > 1
+
+          # continue drilling down the Hash
+          data = data.first.last while data.is_a?(Hash) && 1 == data.size
+
+          # return
+          data
+        end
+
+        def request_object(method, klass, args = {})
+          data = call method, args
+          return nil unless data.is_a?(Hash)
+          klass.new(data)
+        end
+
+        def request_array(method, args = {})
+          data = call method, args
+          data = data.split(/[\s,]+/) if data.is_a?(String)
+          data = [data] if data.is_a?(Hash)
+          data.is_a?(Array) ? data : []
+        end
+
+        def reqeust_object_array(method, klass, args = {})
+          data = request_array(method, args)
+          data.map { |x| klass.new(x) }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/services/rosetta/collection_handler.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+require 'virtus'
+
+require 'libis/tools/extend/hash'
+require_relative 'collection_info'
+require_relative 'client'
+
+module Libis
+  module Services
+    module Rosetta
+
+      class CollectionHandler < Libis::Services::Rosetta::Client
+
+
+        def initialize(base_url = 'http://depot.lias.be', options = {})
+          super 'repository', 'CollectionWebServices', {url: base_url}.merge(options)
+        end
+
+        def get(id)
+          request_object :get_collection_by_id, Rosetta::CollectionInfo, pds_handle: @pds_handle, collection_id: id
+        end
+
+        def find(path)
+          request_object :get_collection_by_name, Rosetta::CollectionInfo, pds_handle: @pds_handle, collection_path: path
+        end
+
+        def create(collection_info)
+          collection_info = collection_info.attributes if collection_info.is_a? CollectionInfo
+          call :create_collection, pds_handle: @pds_handle, collection: collection_info
+        end
+
+        def delete(id)
+          call :delete_collection, pds_handle: @pds_handle, collection_id: id
+        end
+
+        def update(collection_info)
+          collection_info = collection_info.attributes if collection_info.is_a? CollectionInfo
+          call :update_collection, pds_handle: @pds_handle, collection: collection_info
+        end
+
+      end
+
+    end
+  end
+end