collectionspace-client 0.3.0 → 0.14.1

data/lib/collectionspace/client/helpers.rb

@@ -1,6 +1,22 @@
+# frozen_string_literal: true
+
 module CollectionSpace
   # Helper methods for client requests
   module Helpers
+    # add / update batch job
+    def add_batch_job(name, template, data = {}, params = { pgSz: 100 })
+      payload  = Template.process(template, data)
+      response = get('batch', { query: params })
+      create_or_update(response, 'batch', 'name', name, payload)
+    end
+
+    # add / update reports
+    def add_report(data = {}, params = { pgSz: 100 })
+      payload  = Template.process('report', data)
+      response = get('reports', { query: params })
+      create_or_update(response, 'reports', 'name', data[:name], payload)
+    end
+
     # get ALL records at path by paging through record set
     def all(path, options = {})
       list_type, list_item = get_list_types(path)
@@ -9,9 +25,7 @@ module CollectionSpace
 
       Enumerator::Lazy.new(0...iterations) do |yielder, i|
         response = request('GET', path, options.merge(query: { pgNum: i }))
-        unless response.result.success?
-          raise CollectionSpace::RequestError, response.result.body
-        end
+        raise CollectionSpace::RequestError, response.result.body unless response.result.success?
 
         items_in_page = response.parsed[list_type].fetch('itemsInPage', 0).to_i
         list_items = items_in_page.positive? ? response.parsed[list_type][list_item] : []
@@ -24,24 +38,131 @@ module CollectionSpace
     def count(path)
       list_type, = get_list_types(path)
       response   = request('GET', path, query: { pgNum: 0, pgSz: 1 })
-      response.parsed[list_type]['totalItems'].to_i if response.result.success?
+      raise CollectionSpace::RequestError, response.result.body unless response.result.success?
+
+      response.parsed[list_type]['totalItems'].to_i
+    end
+
+    # get the tenant domain from a system required top level authority (person)
+    def domain
+      path = 'personauthorities'
+      response = request('GET', path, query: { pgNum: 0, pgSz: 1 })
+      raise CollectionSpace::RequestError, response.result.body unless response.result.success?
+
+      refname = response.parsed.dig(*get_list_types(path), 'refName')
+      CollectionSpace::RefName.parse(refname)[:domain]
+    end
+
+    # find procedure or object by type and id
+    # find authority/vocab term by type, subtype, and refname
+    # rubocop:disable Metrics/ParameterLists
+    def find(type:, value:, subtype: nil, field: nil, schema: 'common', sort: nil, operator: '=')
+      service = CollectionSpace::Service.get(type: type, subtype: subtype)
+      field ||= service[:term] # this will be set if it is an authority or vocabulary, otherwise nil
+      field ||= service[:identifier]
+      search_args = CollectionSpace::Search.new.from_hash(
+        path: service[:path],
+        namespace: "#{service[:ns_prefix]}_#{schema}",
+        field: field,
+        expression: "#{operator} '#{value.gsub(/'/, '\\\\\'')}'"
+      )
+      search(search_args, sortBy: CollectionSpace::Search::DEFAULT_SORT)
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    # @param subject_csid [String] to be searched as `sbj` value
+    # @param object_csid [String] to be searched as `obj` value
+    # @param rel_type [String<'affects', 'hasBroader'>, nil] to be searched as `prd` value
+    def find_relation(subject_csid:, object_csid:, rel_type: nil)
+      if rel_type
+        get('relations', query: { 'sbj' => subject_csid, 'obj' => object_csid, 'prd' => rel_type })
+      else
+        warn(
+          "No rel_type specified, so multiple types of relations between #{subject_csid} and #{object_csid} may be returned",
+          uplevel: 1
+        )
+        get('relations', query: { 'sbj' => subject_csid, 'obj' => object_csid })
+      end
     end
 
     def get_list_types(path)
       {
         'accounts' => %w[accounts_common_list account_list_item],
-        'relations' => %w[relations_common_list relation_list_item],
+        'relations' => %w[relations_common_list relation_list_item]
       }.fetch(path, %w[abstract_common_list list_item])
     end
 
-    def prepare_query(query, options = {})
-      query_string = "#{query.type}:#{query.field} #{query.expression}"
-      options.merge(query: { as: query_string })
+    def reindex_full_text(doctype, csids = [])
+      if csids.any?
+        run_job(
+          'Reindex Full Text', :reindex_full_text, :reindex_by_csids, { doctype: doctype, csids: csids }
+        )
+      else
+        run_job(
+          'Reindex Full Text', :reindex_full_text, :reindex_by_doctype, { doctype: doctype }
+        )
+      end
     end
 
-    def search(query, options = {})
-      options = prepare_query(query, options)
+    def reset_media_blob(id, url)
+      raise CollectionSpace::ArgumentError, "Not a valid url #{url}" unless URI.parse(url).instance_of? URI::HTTPS
+
+      response = find(type: 'media', value: id, field: 'identificationNumber')
+      raise CollectionSpace::RequestError, response.result.body unless response.result.success?
+
+      found = response.parsed
+      total = found['abstract_common_list']['totalItems'].to_i
+      raise CollectionSpace::NotFoundError, "Media #{id} not found" if total.zero?
+      raise CollectionSpace::DuplicateIdFound, "Found multiple media records for #{id}" unless total == 1
+
+      media_uri = found['abstract_common_list']['list_item']['uri']
+      blob_csid = found['abstract_common_list']['list_item']['blobCsid']
+
+      delete("/blobs/#{blob_csid}") if blob_csid
+
+      payload = Template.process(:reset_media_blob, { id: id })
+      put(media_uri, payload, query: { 'blobUri' => url })
+    end
+
+    def run_job(name, template, invoke_template, data = {})
+      payload = Template.process(invoke_template, data)
+      job     = add_batch_job(name, template)
+      path    = job.parsed['document']['collectionspace_core']['uri']
+      post(path, payload)
+    end
+
+    def search(query, params = {})
+      options = prepare_query(query, params)
       request 'GET', query.path, options
     end
+
+    def keyword_search(type:, value:, subtype: nil, sort: nil)
+      service = CollectionSpace::Service.get(type: type, subtype: subtype)
+      options = prepare_keyword_query(value, { sortBy: CollectionSpace::Search::DEFAULT_SORT })
+      request 'GET', service[:path], options
+    end
+
+    def service(type:, subtype: '')
+      CollectionSpace::Service.get(type: type, subtype: subtype)
+    end
+
+    private
+
+    def create_or_update(response, path, property, value, payload)
+      list_type, item_type = get_list_types(path)
+      item = response.find(list_type, item_type, property, value)
+      path = item ? "#{path}/#{item['csid']}" : path
+      item ? put(path, payload) : post(path, payload)
+    end
+
+    def prepare_query(query, params = {})
+      query_string = "#{query.namespace}:#{query.field} #{query.expression}"
+      { query: { as: query_string }.merge(params) }
+    end
+
+    def prepare_keyword_query(query, sort = {})
+      query_string = query.downcase.gsub(' ', '+')
+      { query: { kw: query_string }.merge(sort) }
+    end
   end
 end

data/lib/collectionspace/client/refname.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+module CollectionSpace
+  # CollectionSpace RefName
+  #
+  # There are four patterns we need to handle:
+  # 
+  # - urn:cspace:domain:type:name(subtype)'label'                       : Top level authority/vocabulary
+  # - urn:cspace:domain:type:name(subtype):item:name(identifier)'label' : Authority/vocabulary term
+  # - urn:cspace:domain:type:id(identifier)'label'                      : Collectionobject
+  # - urn:cspace:domain:type:id(identifier)                             : Procedures, relations, blobs
+  class RefName
+    attr_reader :domain, :type, :subtype, :identifier, :label
+
+    def initialize(refname)
+      @refname    = refname
+      @domain     = nil
+      @type       = nil
+      @subtype    = nil
+      @identifier = nil
+      @label      = nil
+      parse
+    end
+
+    def parse
+      scanner = StringScanner.new(@refname)
+      scanner.skip('urn:cspace:')
+      @domain = to_next_colon(scanner) 
+      @type = to_next_colon(scanner)
+
+      case next_segment(scanner)
+      when 'name'
+        set_subtype(scanner)
+      when 'id'
+        set_identifier(scanner)
+      end
+
+      self
+    end
+   
+    # Convenience class method, so new instance of RefName does not have to be instantiated in order to parse
+    #
+    # As of v0.13.1, return_class is added and defaults to nil for backward compatibility
+    # Eventually this default will be deprecated, and a parsed RefName object will be returned as the default.
+    #   Any new code written using this method should set the return_class parameter to :refname_obj
+    def self.parse(refname, return_class = nil)
+      return_class == :refname_obj ? new(refname) : new(refname).to_h
+    end
+
+    # Returns a parsed RefName object as a hash.
+    # As of v0.13.1, this is equivalent to calling RefName.parse('refnamevalue', :hash)
+    # This was added to simplify the process of updating existing code that expects a hash when calling RefName.parse
+    def to_h
+      {
+        domain: domain,
+        type: type,
+        subtype: subtype,
+        identifier: identifier,
+        label: label
+      }
+    end
+
+    private
+
+    def next_segment(scanner)
+      segment = scanner.check_until(/\(/)
+      return nil unless segment
+      
+      segment.delete_suffix('(')
+    end
+
+    def set_identifier(scanner)
+      scanner.skip('id(')
+      @identifier = to_end_paren(scanner)
+      return if scanner.eos?
+
+      set_label(scanner)
+    end
+
+    def set_label(scanner)
+      scanner.skip("'")
+      @label = scanner.rest.delete_suffix("'")
+    end
+
+    def set_subtype(scanner)
+      scanner.skip('name(')
+      @subtype = to_end_paren(scanner)
+
+      case next_segment(scanner)
+      when nil
+        set_label(scanner)
+      when ':item:name'
+        set_term_identifier(scanner)
+      end
+    end
+
+    def set_term_identifier(scanner)
+      scanner.skip(':item:name(')
+      @identifier = to_end_paren(scanner)
+      scanner.skip("'")
+      set_label(scanner)
+    end
+    
+    def to_end_paren(scanner)
+      scanner.scan_until(/\)/).delete_suffix(')')
+    end
+
+    def to_next_colon(scanner)
+      scanner.scan_until(/:/).delete_suffix(':')
+    end
+  end
+end

data/lib/collectionspace/client/request.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CollectionSpace
   # CollectionSpace request
   class Request

data/lib/collectionspace/client/response.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CollectionSpace
   # CollectionSpace response
   class Response
@@ -10,5 +12,14 @@ module CollectionSpace
       body = result.body
       @xml = @result.success? && body =~ /<?xml/ ? Nokogiri::XML(body) : nil
     end
+
+    def find(list_type, item_type, property, value)
+      total = parsed[list_type]['totalItems'].to_i
+      return unless total.positive?
+
+      list   = parsed[list_type][item_type]
+      list   = [list] if total == 1 # wrap if single item
+      list.find { |i| i[property] == value }
+    end
   end
 end

data/lib/collectionspace/client/search.rb

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
 module CollectionSpace
   # CollectionSpace search
   class Search
-    attr_accessor :path, :type, :field, :expression
+    attr_accessor :path, :namespace, :field, :expression
+
+    DEFAULT_SORT = 'collectionspace_core:updatedAt DESC'
 
-    def initialize(path: nil, type: nil, field: nil, expression: nil)
+    def initialize(path: nil, namespace: nil, field: nil, expression: nil)
       @path       = path
-      @type       = type
+      @namespace  = namespace
       @field      = field
       @expression = expression
     end

data/lib/collectionspace/client/service.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module CollectionSpace
+  # CollectionSpace service
+  class Service
+    TERM_SUFFIX = 'TermGroupList/0/termDisplayName'
+    def self.get(type:, subtype: '')
+      {
+        'acquisitions' => {
+          identifier: 'acquisitionReferenceNumber',
+          ns_prefix: 'acquisitions',
+          path: 'acquisitions',
+          term: nil
+        },
+        'citationauthorities' => {
+          identifier: 'shortIdentifier',
+          ns_prefix: 'citations',
+          path: "citationauthorities/urn:cspace:name(#{subtype})/items",
+          term: "citation#{TERM_SUFFIX}"
+        },
+        'claims' => {
+          identifier: 'claimNumber',
+          ns_prefix: 'claims',
+          path: 'claims',
+          term: nil
+        },
+        'collectionobjects' => {
+          identifier: 'objectNumber',
+          ns_prefix: 'collectionobjects',
+          path: 'collectionobjects',
+          term: nil
+        },
+        'conceptauthorities' => {
+          identifier: 'shortIdentifier',
+          ns_prefix: 'concepts',
+          path: "conceptauthorities/urn:cspace:name(#{subtype})/items",
+          term: "concept#{TERM_SUFFIX}"
+        },
+        'conditionchecks' => {
+          identifier: 'conditionCheckRefNumber',
+          ns_prefix: 'conditionchecks',
+          path: 'conditionchecks',
+          term: nil
+        },
+        'conservation' => {
+          identifier: 'conservationNumber',
+          ns_prefix: 'conservation',
+          path: 'conservation',
+          term: nil
+        },
+        'exhibitions' => {
+          identifier: 'exhibitionNumber',
+          ns_prefix: 'exhibitions',
+          path: 'exhibitions',
+          term: nil
+        },
+        'groups' => {
+          identifier: 'title',
+          ns_prefix: 'groups',
+          path: 'groups',
+          term: nil
+        },
+        'insurances' => {
+          identifier: 'insuranceIndemnityReferenceNumber',
+          ns_prefix: 'insurances',
+          path: 'insurances',
+          term: nil
+        },
+        'intakes' => {
+          identifier: 'entryNumber',
+          ns_prefix: 'intakes',
+          path: 'intakes',
+          term: nil
+        },
+        'loansin' => {
+          identifier: 'loanInNumber',
+          ns_prefix: 'loansin',
+          path: 'loansin',
+          term: nil
+        },
+        'loansout' => {
+          identifier: 'loanOutNumber',
+          ns_prefix: 'loansout',
+          path: 'loansout',
+          term: nil
+        },
+        'locationauthorities' => {
+          identifier: 'shortIdentifier',
+          ns_prefix: 'locations',
+          path: "locationauthorities/urn:cspace:name(#{subtype})/items",
+          term: "loc#{TERM_SUFFIX}"
+        },
+        'materialauthorities' => {
+          identifier: 'shortIdentifier',
+          ns_prefix: 'materials',
+          path: "materialauthorities/urn:cspace:name(#{subtype})/items",
+          term: "material#{TERM_SUFFIX}"
+        },
+        'media' => {
+          identifier: 'identificationNumber',
+          ns_prefix: 'media',
+          path: 'media',
+          term: nil
+        },
+        'movements' => {
+          identifier: 'movementReferenceNumber',
+          ns_prefix: 'movements',
+          path: 'movements',
+          term: nil
+        },
+        'objectexit' => {
+          identifier: 'exitNumber',
+          ns_prefix: 'objectexit',
+          path: 'objectexit',
+          term: nil
+        },
+        'orgauthorities' => {
+          identifier: 'shortIdentifier',
+          ns_prefix: 'organizations',
+          path: "orgauthorities/urn:cspace:name(#{subtype})/items",
+          term: "org#{TERM_SUFFIX}"
+        },
+        'osteology' => {
+          identifier: 'InventoryID',
+          ns_prefix: 'osteology',
+          path: 'osteology',
+          term: nil
+        },
+        'personauthorities' => {
+          identifier: 'shortIdentifier',
+          ns_prefix: 'persons',
+          path: "personauthorities/urn:cspace:name(#{subtype})/items",
+          term: "person#{TERM_SUFFIX}"
+        },
+        'placeauthorities' => {
+          identifier: 'shortIdentifier',
+          ns_prefix: 'places',
+          path: "placeauthorities/urn:cspace:name(#{subtype})/items",
+          term: "place#{TERM_SUFFIX}"
+        },
+        'pottags' => {
+          identifier: 'potTagNumber',
+          ns_prefix: 'pottags',
+          path: 'pottags',
+          term: nil
+        },
+        'propagations' => {
+          identifier: 'propNumber',
+          ns_prefix: 'propagations',
+          path: 'propagations',
+          term: nil
+        },
+        'relations' => {
+          identifier: 'csid',
+          ns_prefix: 'relations',
+          path: 'relations',
+          term: nil
+        },
+        'taxonomyauthority' => {
+          identifier: 'shortIdentifier',
+          ns_prefix: 'taxon',
+          path: "taxonomyauthority/urn:cspace:name(#{subtype})/items",
+          term: "taxon#{TERM_SUFFIX}"
+        },
+        'transports' => {
+          identifier: 'transportReferenceNumber',
+          ns_prefix: 'transports',
+          path: 'transports',
+          term: nil
+        },
+        'uoc' => {
+          identifier: 'referenceNumber',
+          ns_prefix: 'uoc',
+          path: 'uoc',
+          term: nil
+        },
+        'valuationcontrols' => {
+          identifier: 'valuationcontrolRefNumber',
+          ns_prefix: 'valuationcontrols',
+          path: 'valuationcontrols',
+          term: nil
+        },
+        'vocabularies' => {
+          identifier: 'shortIdentifier',
+          ns_prefix: 'vocabularyitems',
+          path: "vocabularies/urn:cspace:name(#{subtype})/items",
+          term: 'displayName'
+        },
+        'workauthorities' => {
+          identifier: 'shortIdentifier',
+          ns_prefix: 'works',
+          path: "workauthorities/urn:cspace:name(#{subtype})/items",
+          term: "work#{TERM_SUFFIX}"
+        }
+      }.fetch(type)
+    end
+  end
+end

data/lib/collectionspace/client/template.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module CollectionSpace
+  module Template
+    def self.list
+      Dir.glob File.join(templates_path, '*.erb')
+    end
+
+    def self.process(template, data)
+      t = ERB.new(read(template))
+      r = t.result(binding).gsub(/\n+/, "\n")
+      Nokogiri::XML.parse(r).to_xml
+    end
+
+    def self.read(file)
+      File.read("#{templates_path}/#{file}.xml.erb")
+    end
+
+    def self.templates_path
+      ENV.fetch(
+        'COLLECTIONSPACE_CLIENT_TEMPLATES_PATH',
+        File.join(File.dirname(File.expand_path(__FILE__)), 'templates')
+      )
+    end
+  end
+end

data/lib/collectionspace/client/templates/reindex_by_csids.xml.erb

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<ns2:invocationContext xmlns:ns2="http://collectionspace.org/services/common/invocable">
+  <mode>list</mode>
+  <docType><%= data[:doctype] %></docType>
+  <listCSIDs>
+<% data[:csids].each do |csid| %>
+    <csid><%= csid %></csid>
+<% end %>
+  </listCSIDs>
+</ns2:invocationContext>

data/lib/collectionspace/client/templates/reindex_by_doctype.xml.erb

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<ns2:invocationContext xmlns:ns2="http://collectionspace.org/services/common/invocable">
+  <mode>nocontext</mode>
+  <docType><%= data[:doctype] %></docType>
+</ns2:invocationContext>

data/lib/collectionspace/client/templates/reindex_full_text.xml.erb

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<document name="batch">
+  <ns2:batch_common xmlns:ns2="http://collectionspace.org/services/batch" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <name>Reindex Full Text</name>
+    <notes>Recomputes the indexed full text of all or specified records.</notes>
+    <className>org.collectionspace.services.batch.nuxeo.ReindexFullTextBatchJob</className>
+    <supportsNoContext>true</supportsNoContext>
+    <supportsSingleDoc>true</supportsSingleDoc>
+    <supportsDocList>true</supportsDocList>
+    <supportsGroup>false</supportsGroup>
+    <createsNewFocus>false</createsNewFocus>
+    <forDocTypes>
+      <forDocType>Acquisition</forDocType>
+      <forDocType>Batch</forDocType>
+      <forDocType>Blob</forDocType>
+      <forDocType>Citation</forDocType>
+      <forDocType>Citationauthority</forDocType>
+      <forDocType>Claim</forDocType>
+      <forDocType>CollectionObject</forDocType>
+      <forDocType>Conceptauthority</forDocType>
+      <forDocType>Conceptitem</forDocType>
+      <forDocType>Contact</forDocType>
+      <forDocType>Dimension</forDocType>
+      <forDocType>Group</forDocType>
+      <forDocType>Intake</forDocType>
+      <forDocType>Loanin</forDocType>
+      <forDocType>Loanout</forDocType>
+      <forDocType>Locationauthority</forDocType>
+      <forDocType>Locationitem</forDocType>
+      <forDocType>Media</forDocType>
+      <forDocType>Movement</forDocType>
+      <forDocType>ObjectExit</forDocType>
+      <forDocType>Organization</forDocType>
+      <forDocType>Orgauthority</forDocType>
+      <forDocType>Osteology</forDocType>
+      <forDocType>Person</forDocType>
+      <forDocType>Personauthority</forDocType>
+      <forDocType>Placeauthority</forDocType>
+      <forDocType>Placeitem</forDocType>
+      <forDocType>PublicItem</forDocType>
+      <forDocType>Relation</forDocType>
+      <forDocType>Report</forDocType>
+      <forDocType>Taxon</forDocType>
+      <forDocType>Taxonomyauthority</forDocType>
+      <forDocType>Vocabulary</forDocType>
+      <forDocType>Vocabularyitem</forDocType>
+      <forDocType>Workauthority</forDocType>
+      <forDocType>Workitem</forDocType>
+    </forDocTypes>
+  </ns2:batch_common>
+</document>

data/lib/collectionspace/client/templates/report.xml.erb

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document name="reports">
+  <ns2:reports_common xmlns:ns2="http://collectionspace.org/services/report">
+    <name><%= data.fetch(:name) %></name>
+    <notes><%= data.fetch(:notes, data[:name]) %></notes>
+    <forDocTypes>
+      <forDocType><%= data.fetch(:doctype) %></forDocType>
+    </forDocTypes>
+    <supportsSingleDoc><%= data.fetch(:supports_single_doc, 'true') %></supportsSingleDoc>
+    <supportsDocList><%= data.fetch(:supports_doc_list, 'false') %></supportsDocList>
+    <supportsGroup><%= data.fetch(:supports_group, 'false') %></supportsGroup>
+    <supportsNoContext><%= data.fetch(:supports_no_context, 'true') %></supportsNoContext>
+    <filename><%= data.fetch(:filename) %></filename>
+    <outputMIME><%= data.fetch(:mimetype, 'application/pdf') %></outputMIME>
+  </ns2:reports_common>
+</document>

data/lib/collectionspace/client/templates/reset_media_blob.xml.erb

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document name="media">
+  <ns2:media_common xmlns:ns2="http://collectionspace.org/services/media" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <identificationNumber><%= data[:id] %></identificationNumber>
+  </ns2:media_common>
+</document>

data/lib/collectionspace/client/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module CollectionSpace
   class Client
-    VERSION = '0.3.0'.freeze
+    VERSION = '0.14.1'
   end
 end