libis-services 0.0.2

data/lib/libis/services/collective_access/item_info.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+
+require_relative 'connector'
+
+module Libis
+  module Services
+    module CollectiveAccess
+
+      class ItemInfo < Connector
+
+        def initialize(host = nil)
+          super 'ItemInfo', host
+        end
+
+        def get_attributes(item, type = nil)
+          type ||= 'ca_objects'
+          request :getAttributes, type: type, item_id: item.to_s
+        end
+
+        def get_attribute(item, attribute, type = nil)
+          type ||= 'ca_objects'
+          request :getAttributesByElement, type: type, item_id: item.to_s, attribute_code_or_id: attribute.to_s
+        end
+
+        def get_items(item_list, bundle, type = nil)
+          type ||= 'ca_objects'
+          r1, a1 = soap_encode item_list
+          r2, a2 = soap_encode bundle
+          request :get, type: type, item_ids: r1, bundles: r2, :attributes! => {item_ids: a1, bundles: a2}
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# coding: utf-8
+
+require 'libis/services/generic_search'
+
+require_relative 'connector'
+
+module Libis
+  module Services
+    module CollectiveAccess
+
+      class Search < Connector
+        include ::Libis::Services::GenericSearch
+
+        def initialize(host = nil)
+          super 'Search', host
+        end
+
+        def query(query, options = {})
+          request :querySoap, type: (options[:index] || 'ca_objects'), query: query
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/services/collective_access/service.rb

@@ -0,0 +1,80 @@
+# coding: utf-8
+
+require_relative 'search'
+require_relative 'item_info'
+require_relative 'cataloguing'
+
+module Libis
+  module Services
+    module CollectiveAccess
+
+      class Service
+
+        attr_reader :search, :info, :cata
+
+        def initialize(host = nil)
+          @search = ::Libis::Services::CollectiveAccess::Search.new host
+          @info = ::Libis::Services::CollectiveAccess::ItemInfo.new host
+          @cata = ::Libis::Services::CollectiveAccess::Cataloguing.new host
+        end
+
+        def authenticate(name = nil, password = nil)
+          result = @search.authenticate name, password
+          result &&= @info.authenticate name, password
+          result && @cata.authenticate(name, password)
+        end
+
+        def deauthenticate
+          @search.deauthenticate
+          @info.deauthenticate
+          @cata.deauthenticate
+        end
+
+        def add_object(label)
+          @cata.add_item idno: label, type_id: 21
+        end
+
+        def search_object(attributes = {})
+          query = attributes.delete :query || ''
+          query = attributes.inject(query) { |q, (k, v)|
+            q << ' AND ' unless q.empty?
+            q << k << ':' if k
+            v = "\"#{v}\"" if v.is_a?(String) and !v.include? '"'
+            q << v
+          }
+          result = @search.query query
+          return nil unless result && result.is_a?(Hash) && !result.empty?
+          result.first[0]
+        end
+
+        def get_object(label)
+          search_object query: "\"#{label}\""
+        end
+
+        def delete_object(object)
+          @cata.remove object
+        end
+
+        def add_attribute(object, attribute, value)
+          @cata.add_attribute object, attribute.to_s, {attribute.to_sym => value}
+        end
+
+        def get_attribute(object, attribute)
+          result = @info.get_attribute object, attribute
+          result = [result] unless result.is_a? Array
+          result
+        end
+
+        def delete_attribute(_, _) #object, attribute)
+
+        end
+
+        def delete_attributes(object)
+          @cata.remove_attributes object
+        end
+
+      end
+
+    end
+  end
+end

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