libis-services 0.1.0-java

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

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'libis/tools/extend/hash'
+require_relative 'client'
+require_relative 'sip'
+require_relative 'ie'
+
+module Libis
+  module Services
+    module Rosetta
+
+      class SipHandler < Libis::Services::Rosetta::Client
+
+        def initialize(base_url = 'http://depot.lias.be', options = {})
+          super 'repository', 'SipWebServices', {url: base_url}.merge(options)
+        end
+
+        def get_info(sip_id)
+          request_object :get_sip_status_info, Rosetta::Sip, arg0: sip_id
+        end
+
+        def get_ies(sip_id)
+          request_array(:get_sip_i_es, arg0: sip_id).map {|ie| Rosetta::Ie.new(pid: ie)}
+
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require 'virtus'
+
+module Libis
+  module Services
+    module Rosetta
+      class User
+        # noinspection RubyResolve
+        include Virtus.model nullify_blank: true
+
+        RECORD_TYPE = %w'USER CONTACT ORGANIZATION STAFF PUBLIC'
+        USER_STATUS = %w'ACTIVE INACTIVE DELETED'
+        USER_ROLES_STATUS = %w'NEW ACTIVE INACTIVE PENDING DELETED'
+        USER_TYPE = %w'CASUAL INTERNAL EXTERNAL INTEXTAUTH'
+
+        attribute :first_name, String
+        attribute :last_name, String
+        attribute :user_name, String
+        attribute :user_group, String
+        attribute :expiry_date, String
+        attribute :job_title, String
+        attribute :default_language, String
+        attribute :street, String
+        attribute :suburb, String
+        attribute :city, String
+        attribute :country, String
+        attribute :address_1, String
+        attribute :address_2, String
+        attribute :address_3, String
+        attribute :address_4, String
+        attribute :address_5, String
+        attribute :zip, Integer
+        attribute :email_address, String
+        attribute :web_site_url, String
+        attribute :telephone_1, String
+        attribute :telephone_2, String
+        attribute :fax, String
+
+        attribute :password, String
+        attribute :password_verify, String
+
+        def to_hash
+          super.cleanup
+        end
+
+        def to_xml
+          Libis::Tools::XmlDocument.build do |xml|
+            # noinspection RubyResolve
+            xml.user_info {
+              xml.parent.default_namespace = 'http://www.exlibrisgroup.com/xsd/dps/backoffice/service'
+              self.attributes.each do |name, value|
+                xml.send(name, xmlns: '') { xml.text(value) } if value
+              end
+            }
+          end.to_xml
+        end
+
+        def self.from_xml(xml)
+          xml_doc = Libis::Tools::XmlDocument.parse(xml)
+          hash = xml_doc.to_hash(
+              strip_namespaces: true,
+              delete_namespace_attributes: true,
+              empty_tag_value: nil,
+              convert_tags_to: lambda { |tag| tag.to_sym }
+          )
+          self.new(hash[:producer_info])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+require 'virtus'
+
+require 'libis/tools/extend/hash'
+require_relative 'client'
+
+module Libis
+  module Services
+    module Rosetta
+
+      class UserManager < Libis::Services::Rosetta::Client
+
+        def initialize(base_url = 'http://depot.lias.be', options = {})
+          super 'infra', 'UserManagerWS', {url: base_url}.merge(options)
+        end
+
+        def user(user_id, user_info)
+          user_info = user_info.to_hash if user_info.is_a? User
+          do_request :update_user, arg0: user_info, arg1: user_id
+        end
+
+        protected
+
+      end
+
+    end
+  end
+end

data/lib/libis/services/rosetta.rb

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

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

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+require 'libis/services/oracle_client'
+require 'libis/tools/xml_document'
+
+module Libis
+  module Services
+    module Scope
+
+      class Search
+        include ::Libis::Services::GenericSearch
+
+        def initialize
+          @doc = nil
+        end
+
+        def find(term, options = {})
+          super
+          OracleClient.new('SCOPE01', 'APLKN_ARCHV_LIAS', 'archvsc').
+              call('kul_packages.scope_xml_meta_file_ed', [term.upcase])
+          err_file = "/nas/vol03/oracle/scope01/#{term}_err.XML"
+          if File.exist? err_file
+            doc = XmlDocument.open(err_file)
+            msg = doc.xpath('/error/error_msg').first.content
+            msg_detail = doc.xpath('/error/error_').first.content
+            File.delete(err_file)
+            @doc = nil
+            raise RuntimeError, "Scope search failed: '#{msg}'. Details: '#{msg_detail}'"
+          else
+            @doc = XmlDocument.open("/nas/vol03/oracle/scope01/#{term}_md.XML").to_hash
+          end
+        end
+
+        def each(_ = {})
+          yield @doc
+        end
+
+        def next_record(_ = {})
+          yield @doc
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/services/search_factory.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+require_relative 'aleph/search'
+require_relative 'primo/search'
+require_relative 'sharepoint/search'
+require_relative 'scope/search'
+
+module Libis
+  module Services
+
+    class SearchFactory
+      def initialize(format, *args)
+        @search_class = self.class.const_get("Libis::Services::#{format}::Search")
+        @search_client = @search_class.new *args
+
+      rescue Exception => e
+        puts e.message
+        exit -1
+      end
+
+      def query(query, options = {})
+        @search_client.get(query, options)
+      end
+
+      def find(term, options = {})
+        @search_client.find(term, options)
+      end
+
+      def each(options = {}, &block)
+        @search_client.each(options, &block)
+      end
+
+      def next_record(options = {}, &block)
+        @search_client.next_record(options, &block)
+      end
+
+    end
+
+  end
+end

data/lib/libis/services/service_error.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module Libis
+  module Services
+
+    class ServiceError < Exception
+      attr_accessor :message
+
+      def initialize(error)
+        @message = error.to_s
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,236 @@
+# coding: utf-8
+
+require 'highline'
+require 'libis/tools/logger'
+
+require 'libis/services/soap_client'
+
+module Libis
+  module Services
+    module Sharepoint
+
+      class Search
+        include ::Libis::Services::SoapClient
+        include ::Libis::Tools::Logger
+        include ::Libis::Services::GenericSearch
+
+        private
+
+        MY_QUERY_SYMBOLS = {
+            nil => 'Eq',
+            '==' => 'Eq',
+            '!=' => 'Neq',
+            '>' => 'Gt',
+            '>=' => 'Geq',
+            '<' => 'Lt',
+            '<=' => 'Leq',
+            'is null' => 'IsNull'
+        }
+
+        MAX_QUERY_RETRY = 10
+
+        public
+
+        def initialize(options = {})
+          options[:server_url] = (options[:url] || 'https://www.groupware.kuleuven.be/sites/lias') + (options[:url_ext] || '/_vti_bin')
+          options[:ssl] = true if options[:server_url] =~ /^https:/
+          # options[:soap_url] = options[:server_url].gsub(/^(https?):\/\/)/,"\\1#{CGI.escape(username)}:#{CGI.escape(password)}@") + '/Lists.asmx'
+          options[:wsse_auth] = [options[:username], options[:password]]
+          options[:soap_url] = options[:server_url] + '/Lists.asmx'
+          options[:wsdl_url] = options[:soap_url] + '?wsdl'
+          configure options[:wsdl_url], options
+          options
+        end
+
+        def query(term, options = {})
+
+          options[:term] = term
+
+          options[:limit] ||= 100
+          options[:value_type] ||= 'Text'
+          options[:query_operator] = MY_QUERY_SYMBOLS[options[:query_operator] || '==']
+
+          options[:query_operator] = 'BeginsWith' if term =~ /^[^*]+\*$/
+          options[:query_operator] = 'Contains' if term =~ /^\*[^*]+\*$/
+
+          restart_query options
+
+          options
+
+        end
+
+        def each(options)
+
+          # we start with a new search
+          restart_query options
+          get_next_set options
+
+          while records_to_process? options
+
+            yield options[:result][:records][options[:current]]
+
+            options[:current] += 1
+
+            get_next_set(options) if require_next_set?(options)
+
+          end
+
+          restart_query(options)
+
+        end
+
+        protected
+
+        def restart_query(options)
+          options[:start_id] = 0
+          options[:result] = nil
+          options[:current] = 0
+          options[:set_count] = 0
+          options[:next_set] = nil
+        end
+
+        def records_to_process?(options)
+          options[:current] < options[:set_count]
+        end
+
+        def require_next_set?(options)
+          options[:current] >= options[:set_count] and options[:next_set]
+        end
+
+        def get_next_set(options)
+
+          options[:current] = 0
+          options[:set_count] = 0
+
+          retry_count = MAX_QUERY_RETRY
+
+          while retry_count > 0
+
+            warn "Retrying (#{retry_count}) ..." if retry_count < MAX_QUERY_RETRY
+
+            query = {
+                'Query' => {
+                    'Where' => {
+                        options[:query_operator] => {
+                            'FieldRef' => '',
+                            'Value' => options[:term],
+                            :attributes! => {
+                                'FieldRef' => {
+                                    'Name' => options[:index]
+                                },
+                                'Value' => {
+                                    'Type' => options[:value_type]
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            query_options = {
+                'QueryOptions' => {
+                    'ViewAttributes' => '',
+                    :attributes! => {
+                        'ViewAttributes' => {
+                            'Scope' => 'RecursiveAll'
+                        }
+                    }
+                }
+            }
+
+            now = Time.now
+            window_start = Time.new(now.year, now.month, now.day, 12, 15)
+            window_end = Time.new(now.year, now.month, now.day, 13, 15)
+            if options[:selection] and now > window_start and now < window_end
+              query_options['QueryOptions']['Folder'] = options[:server_url] + 'Gedeelde%20documenten/' + options[:selection] + '/.'
+            end
+
+            if options[:next_set]
+              query_options['QueryOptions']['Paging'] = ''
+              query_options['QueryOptions'][:attributes!]['Paging'] = {'ListItemCollectionPositionNext' => options[:next_set]}
+            end
+
+            result = request 'GetListItems', {
+                                               soap_options: {
+                                                   endpoint: options[:soap_url]
+                                               },
+                                               wsse_auth: options[:wsse_auth],
+                                               listName: options[:base],
+                                               viewName: '',
+                                               query: query,
+                                               viewFields: {'ViewFields' => ''},
+                                               rowLimit: options[:limit].to_s,
+                                               query_options: query_options,
+                                               webID: ''
+                                           }, {}, options
+
+            if result[:error]
+              warn "SOAP error: '#{result[:error]}'"
+              raise RuntimeError, 'Too many SOAP errors, giving up.' unless retry_count > 0
+            elsif result[:exception]
+              warn "SOAP exception: '#{result[:exception].message}'"
+              raise result[:exception] unless retry_count > 0
+            else
+              options[:result] = result
+              options[:set_count] = result[:count]
+              options[:next_set] = result[:next_set]
+              retry_count = 0
+              retry_count = MAX_QUERY_RETRY + 1 if options[:set_count] == 0 and options[:next_set]
+            end
+
+            retry_count -= 1
+
+          end
+
+        end
+
+        def result_parser(result, options)
+
+          records = []
+          result = result[:get_list_items_response][:get_list_items_result]
+
+          data = result[:listitems][:data]
+
+          rows = data[:row]
+          rows = [rows] unless rows.is_a? Array
+
+          rows.each do |row|
+            if options[:selection].nil? or row[:ows_FileRef] =~ /^\d+;#sites\/lias\/Gedeelde documenten\/#{options[:selection]}(|\/.*)$/
+              records << clean_row(row, options)
+            end
+          end
+
+          next_set = data[:@list_item_collection_position_next]
+
+          # the itemcount in the response is not interesting. We count only the records that match our selection criteria.
+          count = records.size
+
+          {next_set: next_set, records: records, count: count}
+
+        end
+
+        def clean_row(row, options)
+
+          options[:fields_found] ||= Set.new
+          row.keys.each { |k| options[:fields_found] << k }
+
+          fields_to_be_removed = [:ows_MetaInfo]
+          fields_to_be_removed = row.keys - options[:field_selection] if options[:field_selection]
+
+          record = SharepointRecord.new
+
+          row.each do |k, v|
+            key = k.to_s.gsub(/^@/, '').to_sym
+            next if fields_to_be_removed.include? key
+            record[key] = v.dot_net_clean
+          end
+
+          record
+
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# coding: utf-8
+
+require 'libis/services/generic_search'
+
+module Libis
+  module Services
+    module Sharepoint
+
+      class Search
+        include ::Libis::Services::GenericSearch
+
+        def initialize
+          puts 'TODO'
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/services/soap_client.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+require 'savon'
+
+require 'libis/tools/xml_document'
+require_relative 'http_error'
+require_relative 'soap_error'
+
+module Libis
+  module Services
+
+    module SoapClient
+      attr_reader :client
+
+      def configure(wsdl, options = {})
+        opts = {
+            wsdl: wsdl,
+            raise_errors: false,
+            soap_version: 1,
+            filters: [:password],
+            pretty_print_xml: true,
+        }.merge options
+
+        @client = Savon.client(opts) { yield if block_given? }
+      end
+
+      def operations
+        @client.operations
+      end
+
+      def request(method, message = {}, call_options = {}, parse_options = {})
+        response = client.call(method, message: message) do |locals|
+          call_options.each do |key, value|
+            locals.send(key, value)
+          end
+        end
+
+        return yield(response) if block_given?
+        parse_result(response, parse_options)
+      end
+
+      protected
+
+      def parse_result(response, options = {})
+        raise SoapError.new response.soap_fault.to_hash if response.soap_fault?
+        raise HttpError.new response.http_error.to_hash if response.http_error?
+        self.result_parser(response.body, options)
+      end
+
+      def result_parser(response, options = {})
+        response
+      end
+
+    end
+
+  end
+end

data/lib/libis/services/soap_error.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Libis
+  module Services
+
+    class SoapError < Exception
+      attr_accessor :code, :text, :detail, :name
+
+      def initialize(error)
+        @code = error[:fault][:faultcode] rescue nil
+        @text = error[:fault][:faultstring] rescue nil
+        @detail = error[:fault][:detail] rescue nil
+        @name = @detail.first.first rescue nil
+      end
+
+      def message
+        "#{code}:#{name} #{text}"
+      end
+    end
+
+  end
+end

data/lib/libis/services/version.rb

@@ -0,0 +1,5 @@
+module Libis
+  module Services
+    VERSION = '0.1.0'
+  end
+end

data/lib/libis/services.rb

@@ -0,0 +1,22 @@
+module Libis
+  module Services
+
+    autoload :HttpError, 'libis/services/http_error'
+    autoload :SoapError, 'libis/services/soap_error'
+    autoload :ServiceError, 'libis/services/service_error'
+
+    autoload :SoapClient, 'libis/services/soap_client'
+    autoload :RestClient, 'libis/services/rest_client'
+
+    autoload :OracleClient, 'libis/services/oracle_client'
+    autoload :DigitoolConnector, 'libis/services/digitool_connector'
+    autoload :DigitalEntityManager, 'libis/services/digital_entity_manager'
+    autoload :MetaDataManager, 'libis/services/meta_data_manager'
+
+    autoload :SharepointConnector, 'libis/services/sharepoint_connector'
+
+    autoload :Rosetta, 'libis/services/rosetta'
+    autoload :Primo, 'libis/services/primo'
+
+  end
+end

data/lib/libis-services.rb

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

data/libis-services.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'libis/services/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'libis-services'
+  spec.version       = Libis::Services::VERSION
+  spec.authors       = ['Kris Dekeyser']
+  spec.email         = ['kris.dekeyser@libis.be']
+  spec.summary       = %q{LIBIS Services toolbox.}
+  spec.description   = %q{Set of classes that simplify connection to different LIBIS services.}
+  spec.homepage      = 'https://github.com/Kris-LIBIS/LIBIS_Services'
+  spec.license       = 'MIT'
+
+  spec.platform      = Gem::Platform::JAVA if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.3'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'simplecov', '~> 0.9'
+  spec.add_development_dependency 'coveralls', '~> 0.7'
+  spec.add_development_dependency 'equivalent-xml', '~> 0.6'
+
+  spec.add_runtime_dependency 'libis-tools', '~> 0.9'
+  spec.add_runtime_dependency 'highline', '~> 1.7'
+  spec.add_runtime_dependency 'savon', '~> 2.11'
+  spec.add_runtime_dependency 'rest-client', '~> 1.8'
+  spec.add_runtime_dependency 'oai', '~> 0.4'
+  spec.add_runtime_dependency 'virtus', '~> 1.0'
+  spec.add_runtime_dependency 'write_xlsx', '~> 0.83'
+  spec.add_runtime_dependency 'awesome_print', '~> 1.6'
+end