collectionspace-client 0.14.1 → 0.15.1

data/lib/collectionspace/client/helpers.rb

@@ -4,17 +4,35 @@ 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)
+    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 batches and data updates
+    def add_batch(data = {}, params = {pgSz: 100})
+      payload = Template.process("batch", data)
+      response = get("batch", {query: params})
+      create_or_update(response, "batch", "name", data[: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)
+    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
+
+    # returns Array of authority doctypes for use in setting up batches
+    def authority_doctypes
+      response = get("/servicegroups/authority")
+      unless response.result.success?
+        raise CollectionSpace::RequestError, response.result.body
+      end
+
+      result = response.result.parsed_response
+      result.dig("document", "servicegroups_common", "hasDocTypes", "hasDocType")
     end
 
     # get ALL records at path by paging through record set
@@ -24,10 +42,10 @@ module CollectionSpace
       return [] unless iterations.positive?
 
       Enumerator::Lazy.new(0...iterations) do |yielder, i|
-        response = request('GET', path, options.merge(query: { pgNum: i }))
+        response = request("GET", path, options.merge(query: {pgNum: i}))
         raise CollectionSpace::RequestError, response.result.body unless response.result.success?
 
-        items_in_page = response.parsed[list_type].fetch('itemsInPage', 0).to_i
+        items_in_page = response.parsed[list_type].fetch("itemsInPage", 0).to_i
         list_items = items_in_page.positive? ? response.parsed[list_type][list_item] : []
         list_items = [list_items] if items_in_page == 1
 
@@ -37,26 +55,25 @@ module CollectionSpace
 
     def count(path)
       list_type, = get_list_types(path)
-      response   = request('GET', path, query: { pgNum: 0, pgSz: 1 })
+      response = request("GET", path, query: {pgNum: 0, pgSz: 1})
       raise CollectionSpace::RequestError, response.result.body unless response.result.success?
 
-      response.parsed[list_type]['totalItems'].to_i
+      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 })
+      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')
+      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: '=')
+    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]
@@ -64,7 +81,7 @@ module CollectionSpace
         path: service[:path],
         namespace: "#{service[:ns_prefix]}_#{schema}",
         field: field,
-        expression: "#{operator} '#{value.gsub(/'/, '\\\\\'')}'"
+        expression: "#{operator} '#{value.gsub(/'/, "\\\\'")}'"
       )
       search(search_args, sortBy: CollectionSpace::Search::DEFAULT_SORT)
     end
@@ -75,74 +92,118 @@ module CollectionSpace
     # @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 })
+        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 })
+        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]
+        "accounts" => %w[accounts_common_list account_list_item],
+        "relations" => %w[relations_common_list relation_list_item]
       }.fetch(path, %w[abstract_common_list list_item])
     end
 
     def reindex_full_text(doctype, csids = [])
       if csids.any?
         run_job(
-          'Reindex Full Text', :reindex_full_text, :reindex_by_csids, { doctype: doctype, csids: csids }
+          "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 }
+          "Reindex Full Text", :reindex_full_text, :reindex_by_doctype, {doctype: doctype}
         )
       end
     end
 
-    def reset_media_blob(id, url)
-      raise CollectionSpace::ArgumentError, "Not a valid url #{url}" unless URI.parse(url).instance_of? URI::HTTPS
+    # @param id [String] media record's identificationNumber value
+    # @param url [String] blobUri value
+    # @param verbose [Boolean] whether to put brief report of outcome to STDOUT
+    # @param ensure_safe_url [Boolean] set to false if using FILE URIs or
+    #   other non-HTTPS URIs
+    # @param delete_existing_blob [Boolean] set to false if you have already
+    #   manually deleted blobs
+    def reset_media_blob(id:, url:, verbose: false,
+      ensure_safe_url: true,
+      delete_existing_blob: true)
+      if ensure_safe_url
+        unless URI.parse(url).instance_of? URI::HTTPS
+          raise CollectionSpace::ArgumentError, "Not a valid url #{url}"
+        end
+      end
 
-      response = find(type: 'media', value: id, field: 'identificationNumber')
-      raise CollectionSpace::RequestError, response.result.body unless response.result.success?
+      response = find(type: "media", value: id, field: "identificationNumber")
+      unless response.result.success?
+        if verbose
+          puts "#{id}\tfailure\tAPI request error: #{response.result.body}"
+        else
+          raise CollectionSpace::RequestError, response.result.body
+        end
+      end
 
       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
+      total = found["abstract_common_list"]["totalItems"].to_i
+
+      if total.zero?
+        msg = "Media #{id} not found"
+        if verbose
+          puts "#{id}\tfailure\t#{msg}"
+        else
+          raise CollectionSpace::NotFoundError, msg
+        end
+      elsif total > 1
+        msg = "Found multiple media records for #{id}"
+        if verbose
+          puts "#{id}\tfailure\t#{msg}"
+        else
+          raise CollectionSpace::DuplicateIdFound, msg
+        end
+      end
 
-      media_uri = found['abstract_common_list']['list_item']['uri']
-      blob_csid = found['abstract_common_list']['list_item']['blobCsid']
+      media_uri = found["abstract_common_list"]["list_item"]["uri"]
 
-      delete("/blobs/#{blob_csid}") if blob_csid
+      if delete_existing_blob
+        blob_csid = found["abstract_common_list"]["list_item"]["blobCsid"]
+        delete("/blobs/#{blob_csid}") if blob_csid
+      end
 
-      payload = Template.process(:reset_media_blob, { id: id })
-      put(media_uri, payload, query: { 'blobUri' => url })
+      payload = Template.process(:reset_media_blob, {id: id})
+      response = put(media_uri, payload, query: {"blobUri" => url})
+      if verbose
+        if response.result.success?
+          puts "#{id}\tsuccess\t"
+        else
+          puts "#{id}\tfailure\t#{response.parsed}"
+        end
+      else
+        response
+      end
     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']
+      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
+      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
+      options = prepare_keyword_query(value, {sortBy: CollectionSpace::Search::DEFAULT_SORT})
+      request "GET", service[:path], options
     end
 
-    def service(type:, subtype: '')
+    def service(type:, subtype: "")
       CollectionSpace::Service.get(type: type, subtype: subtype)
     end
 
@@ -151,18 +212,18 @@ module CollectionSpace
     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
+      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) }
+      {query: {as: query_string}.merge(params)}
     end
 
     def prepare_keyword_query(query, sort = {})
-      query_string = query.downcase.gsub(' ', '+')
-      { query: { kw: query_string }.merge(sort) }
+      query_string = query.downcase.tr(" ", "+")
+      {query: {kw: query_string}.merge(sort)}
     end
   end
 end

data/lib/collectionspace/client/refname.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'strscan'
+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
@@ -15,38 +15,38 @@ module CollectionSpace
     attr_reader :domain, :type, :subtype, :identifier, :label
 
     def initialize(refname)
-      @refname    = refname
-      @domain     = nil
-      @type       = nil
-      @subtype    = nil
+      @refname = refname
+      @domain = nil
+      @type = nil
+      @subtype = nil
       @identifier = nil
-      @label      = nil
+      @label = nil
       parse
     end
 
     def parse
       scanner = StringScanner.new(@refname)
-      scanner.skip('urn:cspace:')
-      @domain = to_next_colon(scanner) 
+      scanner.skip("urn:cspace:")
+      @domain = to_next_colon(scanner)
       @type = to_next_colon(scanner)
 
       case next_segment(scanner)
-      when 'name'
+      when "name"
         set_subtype(scanner)
-      when 'id'
+      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
+      (return_class == :refname_obj) ? new(refname) : new(refname).to_h
     end
 
     # Returns a parsed RefName object as a hash.
@@ -67,12 +67,12 @@ module CollectionSpace
     def next_segment(scanner)
       segment = scanner.check_until(/\(/)
       return nil unless segment
-      
-      segment.delete_suffix('(')
+
+      segment.delete_suffix("(")
     end
 
     def set_identifier(scanner)
-      scanner.skip('id(')
+      scanner.skip("id(")
       @identifier = to_end_paren(scanner)
       return if scanner.eos?
 
@@ -85,30 +85,30 @@ module CollectionSpace
     end
 
     def set_subtype(scanner)
-      scanner.skip('name(')
+      scanner.skip("name(")
       @subtype = to_end_paren(scanner)
 
       case next_segment(scanner)
       when nil
         set_label(scanner)
-      when ':item:name'
+      when ":item:name"
         set_term_identifier(scanner)
       end
     end
 
     def set_term_identifier(scanner)
-      scanner.skip(':item:name(')
+      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(')')
+      scanner.scan_until(/\)/).delete_suffix(")")
     end
 
     def to_next_colon(scanner)
-      scanner.scan_until(/:/).delete_suffix(':')
+      scanner.scan_until(/:/).delete_suffix(":")
     end
   end
 end

data/lib/collectionspace/client/report.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module CollectionSpace
+  # CollectionSpace report
+  class Report
+    def self.all
+      [
+        {
+          name: "Acquisition Summary",
+          notes: "An acquisition summary report. Runs on a single record only.",
+          doctype: "Acquisition",
+          supports_single_doc: "true",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "false",
+          filename: "acq_basic.jrxml",
+          mimetype: "application/pdf"
+        },
+        {
+          name: "Acquisition Basic List",
+          notes: "Catalog info for objects related to an acquisition record. Runs on a single record only.",
+          doctype: "Acquisition",
+          supports_single_doc: "true",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "false",
+          filename: "Acq_List_Basic.jrxml",
+          mimetype: "application/pdf"
+        },
+        {
+          name: "Condition Check Basic List",
+          notes: "Catalog info for objects related to a condition check record. Runs on a single record only.",
+          doctype: "Conditioncheck",
+          supports_single_doc: "true",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "false",
+          filename: "CC_List_Basic.jrxml",
+          mimetype: "application/pdf"
+        },
+        {
+          name: "Exhibition Basic List",
+          notes: "Catalog info for objects related to a exhibition record. Runs on a single record only.",
+          doctype: "Exhibition",
+          supports_single_doc: "true",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "false",
+          filename: "Exhibition_List_Basic.jrxml",
+          mimetype: "application/pdf"
+        },
+        {
+          name: "Group Basic List",
+          notes: "Catalog info for objects related to a group record. Runs on a single record only.",
+          doctype: "Group",
+          supports_single_doc: "true",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "false",
+          filename: "Group_List_Basic.jrxml",
+          mimetype: "application/pdf"
+        },
+        {
+          name: "Loan In Basic List",
+          notes: "Catalog info for objects related to a loan in record. Runs on a single record only.",
+          doctype: "Loanin",
+          supports_single_doc: "true",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "false",
+          filename: "LoansIn_List_Basic.jrxml",
+          mimetype: "application/pdf"
+        },
+        {
+          name: "Loan Out Basic List",
+          notes: "Catalog info for objects related to a loan out record. Runs on a single record only.",
+          doctype: "Loanout",
+          supports_single_doc: "true",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "false",
+          filename: "LoansOut_List_Basic.jrxml",
+          mimetype: "application/pdf"
+        },
+        {
+          name: "Acquisition Ethnographic Object List",
+          notes: "Core acquisition report. Runs on a single record only.",
+          doctype: "Acquisition",
+          supports_single_doc: "true",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "false",
+          filename: "coreAcquisition.jrxml",
+          mimetype: "application/pdf"
+        },
+        {
+          name: "Group Object Ethnographic Object List",
+          notes: "Core group object report. Runs on a single record only.",
+          doctype: "Group",
+          supports_single_doc: "true",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "false",
+          filename: "coreGroupObject.jrxml",
+          mimetype: "application/pdf"
+        },
+        {
+          name: "Intake Ethnographic Object List",
+          notes: "Core intake report. Runs on a single record only.",
+          doctype: "Intake",
+          supports_single_doc: "true",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "false",
+          filename: "coreIntake.jrxml",
+          mimetype: "application/pdf"
+        },
+        {
+          name: "Loan In Ethnographic Object List",
+          notes: "Core loan in report. Runs on a single record only.",
+          doctype: "Loanin",
+          supports_single_doc: "true",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "false",
+          filename: "coreLoanIn.jrxml",
+          mimetype: "application/pdf"
+        },
+        {
+          name: "Loan Out Ethnographic Object List",
+          notes: "Core loan out report. Runs on a single record only.",
+          doctype: "Loanout",
+          supports_single_doc: "true",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "false",
+          filename: "coreLoanOut.jrxml",
+          mimetype: "application/pdf"
+        },
+        {
+          name: "Object Exit Ethnographic Object List",
+          notes: "Core object exit report. Runs on a single record only.",
+          doctype: "ObjectExit",
+          supports_single_doc: "true",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "false",
+          filename: "coreObjectExit.jrxml",
+          mimetype: "application/pdf"
+        },
+        {
+          name: "Object Valuation",
+          notes: "Returns latest valuation information for selected objects",
+          doctype: "CollectionObject",
+          supports_single_doc: "false",
+          supports_doc_list: "true",
+          supports_group: "false",
+          supports_no_context: "true",
+          filename: "object_valuation.jrxml",
+          mimetype: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        },
+        {
+          name: "Systematic Inventory",
+          notes: "Generate a checklist for performing an inventory on a range of storage locations. Runs on all records, using the provided start and end locations.",
+          doctype: "Locationitem",
+          supports_single_doc: "false",
+          supports_doc_list: "false",
+          supports_group: "false",
+          supports_no_context: "true",
+          filename: "systematicInventory.jrxml",
+          mimetype: "application/pdf"
+        }
+      ]
+    end
+
+    def self.find(key, value)
+      all.find { |report| report[key] == value }
+    end
+  end
+end

data/lib/collectionspace/client/request.rb

@@ -11,21 +11,21 @@ module CollectionSpace
         delete: {},
         get: {},
         post: {
-          'Content-Type' => 'application/xml',
-          'Content-Length' => 'nnnn'
+          "Content-Type" => "application/xml",
+          "Content-Length" => "nnnn"
         },
         put: {
-          'Content-Type' => 'application/xml',
-          'Content-Length' => 'nnnn'
+          "Content-Type" => "application/xml",
+          "Content-Length" => "nnnn"
         }
       }
       headers[method]
     end
 
-    def initialize(config, method = 'GET', path = '', options = {})
+    def initialize(config, method = "GET", path = "", options = {})
       @config = config
       @method = method.downcase.to_sym
-      @path   = path.gsub(%r{^/}, '')
+      @path = path.gsub(%r{^/}, "")
 
       @auth = {
         username: config.username,
@@ -35,11 +35,12 @@ module CollectionSpace
       headers = default_headers(@method).merge(options.fetch(:headers, {}))
       @options = options
       @options[:basic_auth] = @auth
-      @options[:headers]    = headers
-      @options[:verify]     = config.verify_ssl
-      @options[:query]      = options.fetch(:query, {})
+      @options[:headers] = headers
+      @options[:verify] = config.verify_ssl
+      @options[:query] = options.fetch(:query, {})
 
       self.class.base_uri config.base_uri
+      self.class.debug_output $stdout if config.verbose
       self.class.default_params(
         wf_deleted: config.include_deleted,
         pgSz: config.page_size

data/lib/collectionspace/client/response.rb

@@ -6,19 +6,19 @@ module CollectionSpace
     attr_reader :result, :parsed, :status_code, :xml
 
     def initialize(result)
-      @result      = result
-      @parsed      = result.parsed_response
+      @result = result
+      @parsed = result.parsed_response
       @status_code = result.code.to_i
       body = result.body
-      @xml = @result.success? && body =~ /<?xml/ ? Nokogiri::XML(body) : nil
+      @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
+      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 = parsed[list_type][item_type]
+      list = [list] if total == 1 # wrap if single item
       list.find { |i| i[property] == value }
     end
   end

data/lib/collectionspace/client/search.rb

@@ -5,12 +5,12 @@ module CollectionSpace
   class Search
     attr_accessor :path, :namespace, :field, :expression
 
-    DEFAULT_SORT = 'collectionspace_core:updatedAt DESC'
+    DEFAULT_SORT = "collectionspace_core:updatedAt DESC"
 
     def initialize(path: nil, namespace: nil, field: nil, expression: nil)
-      @path       = path
-      @namespace  = namespace
-      @field      = field
+      @path = path
+      @namespace = namespace
+      @field = field
       @expression = expression
     end