libis-services 0.0.2

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

@@ -0,0 +1,26 @@
+require 'virtus'
+
+module Libis
+  module Services
+    module Rosetta
+      class Sip
+        # noinspection RubyResolve
+        include Virtus.model nullify_blank: true
+
+        MODULE = %w'PER'
+        STAGE = %w'Finished'
+        STATUS = %w'FINISHED'
+
+        attribute :id, Integer
+        attribute :module, String
+        attribute :stage, String
+        attribute :status, String
+
+        def to_hash
+          super.cleanup
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# 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
+        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/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/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