libis-services 0.1.0-java

data/lib/libis/services/digitool/digital_entity_manager.rb

@@ -0,0 +1,223 @@
+# coding: utf-8
+
+require 'singleton'
+
+require 'libis/services/soap_client'
+
+#noinspection RubyStringKeysInHashInspection
+module Libis
+  module Services
+    module Digitool
+
+      class DigitalEntityManager
+        include Singleton
+        include Libis::Services::SoapClient
+
+        def initialize
+          setup 'DigitalEntityManager'
+        end
+
+        def create_object(de_info)
+          de_call = create_digital_entity_call de_info, 'create'
+          request :digital_entity_call, :general => general.to_s, :digital_entity_call => de_call.to_s
+        end
+
+        def update_object(de_info, update_options = {})
+          de_call = create_digital_entity_call de_info, 'update', update_options
+          request :digital_entity_call, :general => general.to_s, :digital_entity_call => de_call.to_s
+        end
+
+        def delete_object(pid)
+          de_info = {'pid' => pid}
+          de_options = {'metadata' => 'all', 'relation' => 'all'}
+          de_call1 = create_digital_entity_call de_info, 'update', de_options
+          result = request :digital_entity_call, :general => 200.to_s, :digital_entity_call => de_call1.to_s
+          return result if result[:error] and result[:error].size > 0
+          de_call2 = create_digital_entity_call de_info, 'delete'
+          request :digital_entity_call, :general => general.to_s, :digital_entity_call => de_call2.to_s
+        end
+
+        def retrieve_object(pid)
+          de_info = {'pid' => pid}
+          de_call = create_digital_entity_call de_info, 'retrieve'
+          request :digital_entity_call, :general => general.to_s, :digital_entity_call => de_call.to_s
+        end
+
+        def link_dc(pid, mid)
+          link_md pid, mid, 'descriptive', 'dc'
+        end
+
+        def unlink_dc(pid, mid)
+          unlink_md pid, mid, 'descriptive', 'dc'
+        end
+
+        def unlink_all_dc(pid)
+          unlink_all_md pid, 'descriptive', 'dc'
+        end
+
+        def link_acl(pid, mid)
+          link_md pid, mid, 'accessrights', 'rights_md'
+        end
+
+        def unlink_acl(pid, mid)
+          unlink_md pid, mid, 'accessrights', 'rights_md'
+        end
+
+        def unlink_all_acl(pid)
+          unlink_all_md pid, 'accessrights', 'rights_md'
+        end
+
+        def link_md(pid, mid, md_name, md_type)
+          update_object({'pid' => pid.to_s,
+                         'metadata' =>
+                             [{'cmd' => 'insert',
+                               'link_to_exists' => 'true',
+                               'mid' => mid.to_s,
+                               'name' => md_name,
+                               'type' => md_type
+                              }
+                             ]
+                        },
+                        {'metadata' => 'delta'}
+          )
+        end
+
+        def unlink_md(pid, mid, md_name, md_type)
+          update_object({'pid' => pid.to_s,
+                         'metadata' =>
+                             [{'cmd' => 'delete',
+                               'shared' => 'true',
+                               'mid' => mid.to_s,
+                               'name' => md_name,
+                               'type' => md_type
+                              }
+                             ]
+                        },
+                        {'metadata' => 'delta'}
+          )
+        end
+
+        def unlink_all_md(pid, md_name = nil, md_type = nil)
+          de_info = {'pid' => pid.to_s,
+                     'metadata' =>
+                         [{'cmd' => 'delete',
+                           'shared' => 'true'
+                          }
+                         ]
+          }
+          de_info['metadata'][0]['name'] = md_name if md_name
+          de_info['metadata'][0]['type'] = md_type if md_type
+          update_object(de_info, {'metadata' => 'all'})
+        end
+
+        def add_relations(pid, relation_type, related_pids)
+          relations = []
+          related_pids.each do |p|
+            relations << {'cmd' => 'insert',
+                          'type' => relation_type.to_s,
+                          'pid' => p.to_s
+            }
+          end
+          update_object({'pid' => pid.to_s,
+                         'relation' => relations
+                        },
+                        {'relation' => 'delta'}
+          )
+        end
+
+        def update_stream(pid, filename)
+          update_object({'pid' => pid,
+                         'stream_ref' =>
+                             {'cmd' => 'update',
+                              'store_command' => 'copy',
+                              'location' => 'nfs',
+                              'file_name' => filename
+                             }
+                        }
+          )
+        end
+
+        private
+
+        def create_digital_entity_call(de_info = {}, command = 'create', update_options = {})
+          # de_info is a hash like this:
+          # { 'vpid' => 0, || 'pid' => 0,
+          #   'control' => { 'label' => 'abc', 'usage_type' => 'archive' },
+          #   'metadata' => [ { 'name' => 'descriptive', 'type' => 'dc', 'value' => '<record>...</record>'},
+          #                   { 'cmd' => 'insert', 'link_to_exists' => true, 'mid' => '12345' } ],
+          #   'relation' => [ { 'cmd' => 'update', 'type' => 'manifestation', 'pid' => '12345' },
+          #                   { 'cmd' => 'delete', 'type' => 'part_of', pid => '12345' } ],
+          #   'stream_ref' => { 'file_name' => 'abc.tif', 'file_extension' => 'tif', ... }
+          # }
+          # update_options is something like this:
+          # { 'metadata' => 'delta',
+          #   'relation' => 'all',
+          # }
+          digital_entity_call = Libis::Tools::XmlDocument.new
+          root = digital_entity_call.create_node('digital_entity_call',
+                                                 :namespaces => {:node_ns => 'xb',
+                                                                 'xb' => 'http://com/exlibris/digitool/repository/api/xmlbeans'})
+          digital_entity_call.root = root
+
+          root << (digital_entity = digital_entity_call.create_node('xb:digital_entity'))
+          digital_entity << digital_entity_call.create_text_node('pid', de_info['pid']) if de_info['pid']
+          digital_entity << digital_entity_call.create_text_node('vpid', de_info['vpid']) if de_info['vpid']
+          if de_info['control']
+            digital_entity << (ctrl = digital_entity_call.create_node('control'))
+            de_info['control'].each { |k, v| ctrl << digital_entity_call.create_text_node(k.to_s, v.to_s) }
+          end
+          if de_info['metadata'] || update_options['metadata']
+            attributes = {}
+            cmd = update_options.delete 'metadata'
+            attributes['cmd'] = 'delete_and_insert_' + cmd if cmd
+            digital_entity << (mds = digital_entity_call.create_node('mds', :attributes => attributes))
+            if de_info['metadata']
+              de_info['metadata'].each do |m|
+                attributes = {}
+                shared = m.delete 'shared'
+                attributes['shared'] = shared if shared
+                cmd = m.delete 'cmd'
+                attributes['cmd'] = cmd if cmd
+                link_to_exists = m.delete 'link_to_exists'
+                attributes['link_to_exists'] = link_to_exists if link_to_exists
+                mds << (md = digital_entity_call.create_node('md', :attributes => attributes))
+                m.each { |k, v| md << digital_entity_call.create_text_node(k.to_s, v.to_s) }
+              end
+            end
+          end
+          if de_info['relation'] || update_options['relation']
+            attributes = {}
+            cmd = update_options.delete 'relation'
+            attributes['cmd'] = 'delete_and_insert_' + cmd if cmd
+            digital_entity << (relations = digital_entity_call.create_node('relations', :attributes => attributes))
+            if de_info['relation']
+              de_info['relation'].each do |r|
+                attributes = {}
+                cmd = r.delete 'cmd'
+                attributes['cmd'] = cmd if cmd
+                relations << (relation = digital_entity_call.create_node('relation', :attributes => attributes))
+                r.each { |k, v| relation << digital_entity_call.create_text_node(k.to_s, v.to_s) }
+              end
+            end
+          end
+          f = de_info['stream_ref']
+          if f
+            attributes = {}
+            cmd = f.delete 'cmd'
+            attributes['cmd'] = cmd if cmd
+            store_command = f.delete 'store_command'
+            attributes['store_command'] = store_command if store_command
+            location = f.delete 'location'
+            attributes['location'] = location if location
+            digital_entity << (stream_ref = digital_entity_call.create_node('stream_ref', :attributes => attributes))
+            de_info['stream_ref'].each { |k, v| stream_ref << digital_entity_call.create_text_node(k.to_s, v.to_s) }
+          end
+          root << digital_entity_call.create_text_node('command', command)
+          digital_entity_call.document
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/services/digitool/digitool_connector.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+require 'libis/tools/xml_document'
+require 'libis/services/soap_client'
+
+module Libis
+  module Services
+    module Digitool
+
+      class DigitoolConnector
+        include Libis::Services::SoapClient
+
+        def initialize(service, host = nil)
+          @host = host || 'aleph08.libis.kuleuven.be:1801'
+          @service = service.to_s.downcase
+        end
+
+        def init
+          @base_url = "http://#{@host}/de_repository_web/services/"
+          @wsdl_extension = '?wsdl'
+        end
+
+        protected
+
+        def result_parser(response, options = {})
+          result = get_xml_response(response)
+          error = nil
+          pids = nil
+          mids = nil
+          de = nil
+          doc = Libis::Tools::XmlDocument.parse(result)
+          doc.xpath('//error_description').each { |x| error ||= []; error << x.content unless x.content.nil? }
+          doc.xpath('//pid').each { |x| pids ||= []; pids << x.content unless x.content.nil? }
+          doc.xpath('//mid').each { |x| mids ||= []; mids << x.content unless x.content.nil? }
+          doc.xpath('//xb:digital_entity').each { |x| de ||= []; de << x.to_s }
+          {errors: error, pids: pids, mids: mids, digital_entities: de}
+        end
+
+        def get_xml_response(response)
+          response.first[1][response.first[1][:result].snakecase.to_sym]
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/services/digitool/meta_data_manager.rb

@@ -0,0 +1,193 @@
+# coding: utf-8
+
+require 'singleton'
+#require 'iconv'
+#require 'htmlentities'
+
+require 'libis/services/soap_client'
+
+module Libis
+  module Services
+    module Digitool
+
+      # noinspection RubyStringKeysInHashInspection
+      class MetaDataManager
+        include Singleton, Libis::Services::SoapClient
+
+        def initialize
+          setup 'MetaDataManager'
+        end
+
+        def create_dc(dc)
+          dc_string = dc.to_s
+          dc_string.force_encoding('UTF-8')
+          dc_string.gsub!(/<\?xml[^\?]*\?>(\n)*/x, '')
+          dc_string = '<?xml version="1.0" encoding="UTF-8"?>' + dc_string
+#    dc_string.gsub!('&','&amp;')
+#    dc_string.gsub!('<', '&lt;')
+#    dc_string = HTMLEntities.new.encode(dc_string, :named)
+          request :create_meta_data_entry, :general => general.to_s, :description => nil, :name => 'descriptive', :type => 'dc', :value => dc_string
+        end
+
+        def create_dc_from_xml(xml_doc)
+          create_dc_record_from_xml xml_doc
+        end
+
+        def update_dc(mid, dc)
+          request :update_meta_data_entry, :mid => mid.to_s, :general => general.to_s, :description => nil, :name => 'descriptive', :type => 'dc', :value => dc.to_s
+        end
+
+        def create_acl(acl)
+          request :create_meta_data_entry, :general => general.to_s, :description => nil, :name => 'accessrights', :type => 'rights_md', :value => acl.to_s
+        end
+
+        def update_acl(mid, acl)
+          request :update_meta_data_entry, :mid => mid.to_s, :general => general.to_s, :description => nil, :name => 'accessrights', :type => 'rights_md', :value => acl.to_s
+        end
+
+        def delete(mid)
+          request :delete_meta_data_entry, :mid => mid.to_s, :general => general.to_s
+        end
+
+        def retrieve(mid)
+          request :retrieve_meta_data_entry, :mid => mid.to_s, :general => general.to_s
+        end
+
+        def create_dc_record_from_xml(xml_doc)
+          doc = Libis::Tools::XmlDocument.open xml_doc
+          records = doc.xpath('/records/record')
+          return nil unless records.size > 0
+          create_dc(records[0])
+        end
+
+        def create_dc_record(dc_info)
+          doc = Libis::Tools::XmlDocument.new
+          doc.root = doc.create_node('record',
+                                     :namespaces => {'dc' => 'http://purl.org/dc/elements/1.1',
+                                                     'dcterms' => 'http://purl.org/dc/terms',
+                                                     'xsi' => 'http://www.w3.org/2001/XMLSchema-instance'})
+          if dc_info
+            dc_info.each do |k, v|
+              doc.root << (n = doc.create_text_node(k.to_s, v.to_s))
+              n['xsi:type'] = 'dcterms:URI' if v =~ /^http:\/\//
+            end
+          end
+          doc
+        end
+
+        def create_acl_record(acl_info = nil)
+          doc = Libis::Tools::XmlDocument.new
+          doc.root = doc.create_node('access_right_md',
+                                     :namespaces => {:node_ns => 'ar',
+                                                     'ar' => 'http://com/exlibris/digitool/repository/api/xmlbeans',
+                                                     'xs' => 'http://www.w3.org/2001/XMLSchema'})
+          root = doc.root
+          root['enabled'] = 'true'
+          return doc unless acl_info
+          c = acl_info[:copyright]
+          add_acl_copyright(doc, c[:text_file], c[:required]) if c
+          e = acl_info[:conditions]
+          if e
+            e.each do |x|
+              add_acl_condition(doc, x[:expressions], x[:negate])
+            end
+          end
+          doc
+        end
+
+        def add_acl_copyright(doc, text_file, required = true)
+          root = doc.root
+          top = root.xpath('ar_copyrigths')
+          if top.empty?
+            top = doc.create_node('ar_copyrights')
+            root << top
+          else
+            top = top[0]
+          end
+          top['required'] = required.to_s if required
+          child = top.xpath('text_file')
+          child = child.empty? ? doc.create_node('text_file') : top[0]
+          child.content = text_file
+          top << child
+          doc
+        end
+
+        def add_acl_user_group_ip(doc, user, group, iprange, negate = false)
+          expressions = []
+          user.split.each { |u| expressions << create_acl_expression_user(u) } if user
+          group.split.each { |g| expressions << create_acl_expression_group(g) } if group
+          iprange.split.each { |i| expressions << create_acl_expression_iprange(i) } if iprange
+          add_acl_condition doc, expressions, negate
+        end
+
+        def add_acl_user(doc, user, negate = false)
+          expressions = Array.new
+          user.split.each { |u| expressions << create_acl_expression_user(u, negate) }
+          add_acl_condition doc, expressions
+        end
+
+        def add_acl_group(doc, group, negate = false)
+          expressions = Array.new
+          group.split.each { |g| expressions << create_acl_expression_group(g, negate) }
+          add_acl_condition doc, expressions
+        end
+
+        def add_acl_iprange(doc, iprange, negate = false)
+          expressions = Array.new
+          iprange.split.each { |i| expressions << create_acl_expression_iprange(i, negate) }
+          add_acl_condition doc, expressions
+        end
+
+        def add_acl_condition(doc, expressions, negate = false)
+          root = doc.root
+          top = root.xpath('ar_conditions')
+          if top.empty?
+            top = doc.create_node('ar_conditions')
+            root << top
+          else
+            top = top[0]
+          end
+          top << (cond_node = doc.create_node('ar_condition'))
+          cond_node['negate'] = negate.to_s if negate
+          cond_node << (exprs_node = doc.create_node('ar_expressions'))
+          expressions.each do |e|
+            exprs_node << (expr_node = doc.create_node('ar_expression'))
+            expr_node['negate'] = e[:negate].to_s if e[:negate]
+            expr_node['ar_operation'] = e[:operation].to_s if e[:operation]
+            expr_node << doc.create_text_node('key', e[:key].to_s)
+            expr_node << doc.create_text_node('val1', e[:val1].to_s)
+            expr_node << doc.create_text_node('val2', e[:val2].to_s) if e[:val2]
+          end
+          doc
+        end
+
+        def create_acl_expression_user(user, negate = false)
+          {:operation => 'eq',
+           :negate => negate.to_s,
+           :key => 'user_id',
+           :val1 => user.to_s
+          }
+        end
+
+        def create_acl_expression_group(group, negate = false)
+          {:operation => 'eq',
+           :negate => negate.to_s,
+           :key => 'group_id',
+           :val1 => group.to_s
+          }
+        end
+
+        def create_acl_expression_iprange(iprange, negate = false)
+          return nil unless iprange =~ /(\d+\.\d+\.\d+\.\d+)-(\d+\.\d+\.\d+\.\d+)/
+          {:operation => 'within',
+           :negate => negate.to_s,
+           :key => 'ip_range',
+           :val1 => $1,
+           :val2 => $2
+          }
+        end
+
+      end
+    end
+  end
+end

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/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