libis-services 0.1.0-java

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/primo.rb

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

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/client.rb

@@ -0,0 +1,108 @@
+# coding: utf-8
+
+require 'awesome_print'
+
+require 'libis/tools/extend/hash'
+require 'libis/tools/config'
+require 'libis/tools/logger'
+
+require 'libis/services/soap_client'
+require 'libis/services/service_error'
+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
+            msg = data.delete(:error_description) || data.delete(:message_desc)
+            raise Libis::Services::ServiceError.new(msg)
+          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 request_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.to_hash.cleanup 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

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'virtus'
+
+module Libis
+  module Services
+    module Rosetta
+
+      class CollectionInfo
+        # noinspection RubyResolve
+        include Virtus.model
+
+        class MetaData
+          # noinspection RubyResolve
+          include Virtus.model
+
+          attribute :mid, String
+          attribute :type, String
+          attribute :sub_type, String
+          attribute :content, String
+        end
+
+        attribute :id, String
+        attribute :name, String
+        attribute :parent_id, String
+        attribute :description, String
+        attribute :md_dc, MetaData
+        attribute :md_source, Array[MetaData]
+        attribute :navigate, Boolean
+        attribute :publish, Boolean
+        attribute :external_id, String
+        attribute :external_system, String
+
+        def to_hash
+          result = self.attributes
+          result[:md_dc] = result[:md_dc].attributes if result[:md_dc]
+          result[:md_source] = result[:md_source].map { |md| md.attributes }
+          result
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'virtus'
+require 'libis/tools/extend/hash'
+
+module Libis
+  module Services
+    module Rosetta
+      class DepositActivity
+        # noinspection RubyResolve
+        include Virtus.model nullify_blank: true
+
+        STATUS = %w'Inprocess Incomplete Rejected Draft Approved Declined'
+
+        attribute :deposit_activity_id, Integer
+        attribute :creation_date, String
+        attribute :status, String
+        attribute :title, String
+        attribute :producer_agent_id, Integer
+        attribute :submit_date, String
+        attribute :update_date, String
+        attribute :sip_id, Integer
+        attribute :producer_id, Integer
+        attribute :sip_reason, String
+
+        def to_hash
+          super.cleanup
+        end
+
+      end
+
+      class DepositActivityList
+        # noinspection RubyResolve
+        include Virtus.model nullify_blank: true
+
+        attribute :total_records, String
+        attribute :records, Array(DepositActivity)
+
+        def to_hash
+          {
+              total_records: total_records,
+              records: records.map {|record| record.to_hash}
+          }
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,187 @@
+# encoding: utf-8
+
+require_relative 'deposit_activity'
+require_relative 'client'
+
+module Libis
+  module Services
+    module Rosetta
+
+      class DepositHandler < ::Libis::Services::Rosetta::Client
+
+        def initialize(base_url = 'http://depot.lias.be', options = {})
+          super 'deposit', 'DepositWebServices', {url: base_url}.merge(options)
+        end
+
+        # @param [Object] flow_id ID of the material flow used
+        # @param [Object] subdir name of the load directory
+        # @param [Object] producer_id ID of the Producer
+        # @param [Object] deposit_set_id ID of the set of deposits
+        def submit(flow_id, subdir, producer_id, deposit_set_id = '1')
+          call :submit_deposit_activity,
+                     arg0: @pds_handle,
+                     arg1: flow_id,
+                     arg2: subdir,
+                     arg3: producer_id,
+                     arg4: deposit_set_id
+        end
+
+        def deposits(opts = {})
+          options = opts.dup
+          flow_id = options.delete :flow_id
+          submit_date_from, submit_date_to = options.delete :submit_date
+          submit_date_to ||= submit_date_from if submit_date_from
+          update_date_from, update_date_to = options.delete :update_date
+          update_date_to ||= update_date_from if update_date_from
+          if submit_date_from
+            if flow_id
+              get_by_submit_flow submit_date_from, submit_date_to, flow_id, options
+            else
+              get_by_submit_date submit_date_from, submit_date_to, options
+            end
+          elsif update_date_from
+            if flow_id
+              get_by_update_flow update_date_from, update_date_to, flow_id, options
+            else
+              get_by_update_date update_date_from, update_date_to, options
+            end
+          else
+            error "unsupported deposit query: #{opts}."
+            []
+          end
+        end
+
+        # @param [String] date_from Start date for lookup range
+        # @param [String] date_to End date for lookup range
+        # @param [Hash] options optional string parameters limiting the search with:
+        # - status: Status of the deposit [All (default), In process, Rejected, Draft, Approved, Declined]
+        # - producer_id: optional, limits by producer_id
+        # - agent_id: optional, limits by agent_id
+        # - start_record: optional, pagination start
+        # - end_record: optional, pagination end
+        def get_by_submit_date(date_from, date_to, options = {})
+          options = {
+              status: 'All',
+              producer_id: nil,
+              agent_id: nil,
+              start_record: nil,
+              end_record: nil
+          }.merge options
+          params = {
+              arg0: @pds_handle,
+              arg1: options[:status],
+              arg2: options[:producer_id],
+              arg3: options[:agent_id],
+              arg4: date_from,
+              arg5: date_to,
+              arg6: options[:start_record],
+              arg7: options[:end_record]
+          }.cleanup
+          request_activities :get_deposit_activity_by_submit_date, params
+        end
+
+        # @param [String] date_from Start date for lookup range
+        # @param [String] date_to End date for lookup range
+        # @param [Object] flow_id ID of the material flow used
+        # @param [Hash] options optional string parameters limiting the search with:
+        # - status: Status of the deposit [All (default), In process, Rejected, Draft, Approved, Declined]
+        # - producer_id: optional, limits by producer_id
+        # - agent_id: optional, limits by agent_id
+        # - start_record: optional, pagination start
+        # - end_record: optional, pagination end
+        def get_by_submit_flow(date_from, date_to, flow_id, options = {})
+          options = {
+              status: 'All',
+              producer_id: nil,
+              agent_id: nil,
+              start_record: nil,
+              end_record: nil
+          }.merge options
+          params = {
+              arg0: @pds_handle,
+              arg1: options[:status],
+              arg2: flow_id,
+              arg3: options[:producer_id],
+              arg4: options[:agent_id],
+              arg5: date_from,
+              arg6: date_to,
+              arg7: options[:start_record],
+              arg8: options[:end_record]
+          }.cleanup
+          request_activities :get_deposit_activity_by_submit_date_by_material_flow, params
+        end
+
+        # @param [String] date_from Start date for lookup range
+        # @param [String] date_to End date for lookup range
+        # @param [Hash] options optional string parameters limiting the search with:
+        # - status: Status of the deposit [All (default), In process, Rejected, Draft, Approved, Declined]
+        # - producer_id: optional, limits by producer_id
+        # - agent_id: optional, limits by agent_id
+        # - start_record: optional, pagination start
+        # - end_record: optional, pagination end
+        def get_by_update_date(date_from, date_to, options = {})
+          options = {
+              status: 'All',
+              producer_id: nil,
+              agent_id: nil,
+              start_record: nil,
+              end_record: nil
+          }.merge options
+          params = {
+              arg0: @pds_handle,
+              arg1: options[:status],
+              arg2: options[:producer_id],
+              arg3: options[:agent_id],
+              arg4: date_from,
+              arg5: date_to,
+              arg6: options[:start_record],
+              arg7: options[:end_record]
+          }.cleanup
+          request_activities :get_deposit_activity_by_update_date, params
+        end
+
+        # @param [String] date_from Start date for lookup range
+        # @param [String] date_to End date for lookup range
+        # @param [Object] flow_id ID of the material flow used
+        # @param [Hash] options optional string parameters limiting the search with:
+        # - status: Status of the deposit [All (default), In process, Rejected, Draft, Approved, Declined]
+        # - producer_id: optional, limits by producer_id
+        # - agent_id: optional, limits by agent_id
+        # - start_record: optional, pagination start
+        # - end_record: optional, pagination end
+        def get_by_update_flow(date_from, date_to, flow_id, options = {})
+          options = {
+              status: 'All',
+              producer_id: nil,
+              agent_id: nil,
+              start_record: nil,
+              end_record: nil
+          }.merge options
+          params = {
+              arg0: @pds_handle,
+              arg1: options[:status],
+              arg2: flow_id,
+              arg3: options[:producer_id],
+              arg4: options[:agent_id],
+              arg5: date_from,
+              arg6: date_to,
+              arg7: options[:start_record],
+              arg8: options[:end_record]
+          }.cleanup
+          request_activities :get_deposit_activity_by_update_date_by_material_flow, params
+        end
+
+        protected
+
+        def request_activities(method, args = {})
+          data = call method, args
+          list = Rosetta::DepositActivityList.new(total_records: data[:total_records])
+          records = data[:records][:record]
+          list.records = (records.is_a?(Array) ? records : [records]).map { |record| Rosetta::DepositActivity.new(record)}
+          list
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'virtus'
+
+module Libis
+  module Services
+    module Rosetta
+      class Ie
+        # noinspection RubyResolve
+        include Virtus.model nullify_blank: true
+
+        attribute :pid, String
+
+        def to_hash
+          super.cleanup
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'libis/tools/xml_document'
+require_relative 'client'
+
+module Libis
+  module Services
+    module Rosetta
+
+      class IeHandler < Libis::Services::Rosetta::Client
+
+        def initialize(base_url = 'http://depot.lias.be', options = {})
+          super 'repository', 'IEWebServices', {url: base_url}.merge(options)
+        end
+
+        def get_mets(ie, flags = 0)
+          result = call_raw :get_ie, pds_handle: @pds_handle, ie_pid: ie, flags: flags
+          Libis::Tools::MetsFile.parse(result)
+        end
+
+        def get_metadata(ie)
+          result = call_raw :get_md, pds_handle: @pds_handle, 'PID' => ie
+          Libis::Tools::MetsFile.parse(result)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# encoding: utf-8
+require 'oai'
+require 'libis/tools/extend/hash'
+
+module Libis
+  module Services
+    module Rosetta
+      class OaiPmh
+        include OAI::XPath
+
+        def initialize(base_url = 'http://depot.lias.be', options = {})
+          @oai_client = OAI::Client.new(base_url + '/oaiprovider/request', options)
+        end
+
+        def sets
+          response = @oai_client.list_sets
+          response.map do |oai_set|
+            {name: oai_set.name, spec: oai_set.spec, description: oai_set.description}.cleanup
+          end
+        end
+
+        def collections(institute, status = {})
+          result = records("#{institute}-collections", status)
+          result.map do |record|
+            record[:title] = xpath_first(record[:metadata], './/dc:title').text
+          end
+        end
+
+        def records(spec, status = {})
+          options = { set: spec }
+          options[:resumption_token] = status[:token] if status[:token]
+          result = []
+          response = @oai_client.list_records(options)
+          response.each do |record|
+            next if record.deleted?
+            result << {
+                id: record.header.identifier,
+                date: record.header.datestamp,
+                metadata: record.metadata,
+            }
+          end
+          result
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'virtus'
+
+module Libis
+  module Services
+    module Rosetta
+      class OaiSet
+        # noinspection RubyResolve
+        include Virtus.model nullify_blank: true
+
+        attribute :description, String
+        attribute :name, String
+        attribute :spec, String
+
+        def to_hash
+          super.cleanup
+        end
+
+      end
+    end
+  end
+end