dor-services 6.0.5 → 6.1.0

data/lib/dor/services/search_service.rb

@@ -17,18 +17,18 @@ module Dor
         client = Config.fedora.client['risearch']
         client.options[:timeout] = opts.delete(:timeout)
         query_params = {
-          :type => 'tuples',
-          :lang => 'itql',
-          :format => 'CSV',
-          :limit => '1000',
-          :stream => 'on',
-          :query => query
+          type: 'tuples',
+          lang: 'itql',
+          format: 'CSV',
+          limit: '1000',
+          stream: 'on',
+          query: query
         }.merge(opts)
         result = client.post(query_params)
         result.split(/\n/)[1..-1].collect { |pid| pid.chomp.sub(/^info:fedora\//, '') }
       end
 
-      def iterate_over_pids(opts = {}, &block)
+      def iterate_over_pids(opts = {})
         opts[:query] ||= 'select $object from <#ri> where $object <info:fedora/fedora-system:def/model#label> $label'
         opts[:in_groups_of] ||= 100
         opts[:mode] ||= :single
@@ -46,7 +46,7 @@ module Dor
       end
 
       def query(query, args = {})
-        params = args.merge({ :q => query })
+        params = args.merge(q: query)
         params[:start] ||= 0
         resp = solr.get 'select', params: params
         return resp unless block_given?
@@ -68,7 +68,7 @@ module Dor
         end
         q = "{!term f=#{Solrizer.solr_name 'identifier', :symbol}}#{id}"
         result = []
-        query(q, :fl => 'id', :rows => 1000, :defType => 'lucene') do |resp|
+        query(q, fl: 'id', rows: 1000, defType: 'lucene') do |resp|
           result += resp['response']['docs'].collect { |doc| doc['id'] }
           true
         end
@@ -86,7 +86,7 @@ module Dor
       end
 
       def find_sdr_graveyard_apo_druid
-        r = Dor::SearchService.query('dc_title_tesim:"SDR Graveyard"', :fl => 'id')
+        r = Dor::SearchService.query('dc_title_tesim:"SDR Graveyard"', fl: 'id')
         if r['response']['docs'].empty?
           nil
         else

data/lib/dor/services/secondary_file_name_service.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Dor
+  # Merges contentMetadata from several objects into one.
+  class SecondaryFileNameService
+    def self.create(old_name, sequence_num)
+      old_name =~ /^(.*)\.(.*)$/ ? "#{Regexp.last_match(1)}_#{sequence_num}.#{Regexp.last_match(2)}" : "#{old_name}_#{sequence_num}"
+    end
+  end
+end

data/lib/dor/services/shelving_service.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Dor
+  # Push file changes for shelve-able files into the stacks
+  class ShelvingService
+    def self.shelve(work)
+      new(work).shelve
+    end
+
+    def initialize(work)
+      @work = work
+    end
+
+    def shelve
+      # retrieve the differences between the current contentMetadata and the previously ingested version
+      diff = shelve_diff
+      stacks_object_pathname = stacks_location
+      # determine the location of the object's files in the stacks area
+      stacks_druid = DruidTools::StacksDruid.new work.id, stacks_object_pathname
+      stacks_object_pathname = Pathname(stacks_druid.path)
+      # determine the location of the object's content files in the workspace area
+      workspace_druid = DruidTools::Druid.new(work.id, Config.stacks.local_workspace_root)
+      workspace_content_pathname = workspace_content_dir(diff, workspace_druid)
+      # delete, rename, or copy files to the stacks area
+      DigitalStacksService.remove_from_stacks(stacks_object_pathname, diff)
+      DigitalStacksService.rename_in_stacks(stacks_object_pathname, diff)
+      DigitalStacksService.shelve_to_stacks(workspace_content_pathname, stacks_object_pathname, diff)
+    end
+
+    private
+
+    attr_reader :work
+
+    # retrieve the differences between the current contentMetadata and the previously ingested version
+    # (filtering to select only the files that should be shelved to stacks)
+    def shelve_diff
+      raise Dor::ParameterError, 'Missing Dor::Config.stacks.local_workspace_root' if Config.stacks.local_workspace_root.nil?
+      raise Dor::Exception, 'Missing contentMetadata datastream' if work.contentMetadata.nil?
+
+      inventory_diff = Sdr::Client.get_content_diff(work.pid, work.contentMetadata.content, 'shelve')
+      inventory_diff.group_difference('content')
+    end
+
+    # Find the location of the object's content files in the workspace area
+    # @param [Moab::FileGroupDifference] content_diff The differences between the current contentMetadata and the previously ingested version
+    # @param [DruidTools::Druid] workspace_druid the location of the object's files in the workspace area
+    # @return [Pathname] The location of the object's content files in the workspace area
+    def workspace_content_dir(content_diff, workspace_druid)
+      deltas = content_diff.file_deltas
+      filelist = deltas[:modified] + deltas[:added] + deltas[:copyadded].collect { |_old, new| new }
+      return nil if filelist.empty?
+
+      Pathname(workspace_druid.find_filelist_parent('content', filelist))
+    end
+
+    # get the stack location based on the contentMetadata stacks attribute
+    # or using the default value from the config file if it doesn't exist
+    def stacks_location
+      return Config.stacks.local_stacks_root unless work.contentMetadata&.stacks.present?
+
+      location = work.contentMetadata.stacks[0]
+      return location if location.start_with? '/' # Absolute stacks path
+
+      raise "stacks attribute for item: #{work.id} contentMetadata should start with /. The current value is #{location}"
+    end
+  end
+end

data/lib/dor/services/status_service.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Dor
+  # Query the processing status of an item.
+  # This has a dependency on the workflow service (app) to get milestones.
+  class StatusService
+    # verbiage we want to use to describe an item when it has completed a particular step
+    STATUS_CODE_DISP_TXT = {
+      0 => 'Unknown Status', # if there are no milestones for the current version, someone likely messed up the versioning process.
+      1 => 'Registered',
+      2 => 'In accessioning',
+      3 => 'In accessioning (described)',
+      4 => 'In accessioning (described, published)',
+      5 => 'In accessioning (described, published, deposited)',
+      6 => 'Accessioned',
+      7 => 'Accessioned (indexed)',
+      8 => 'Accessioned (indexed, ingested)',
+      9 => 'Opened'
+    }.freeze
+
+    # milestones from accessioning and the order they happen in
+    STEPS = {
+      'registered' => 1,
+      'submitted' => 2,
+      'described' => 3,
+      'published' => 4,
+      'deposited' => 5,
+      'accessioned' => 6,
+      'indexed' => 7,
+      'shelved' => 8,
+      'opened' => 9
+    }.freeze
+
+    # @return [Hash{Symbol => Object}] including :current_version, :status_code and :status_time
+    def self.status_info(work)
+      new(work).status_info
+    end
+
+    def self.status(work, include_time = false)
+      new(work).status(include_time)
+    end
+
+    def initialize(work)
+      @work = work
+    end
+
+    # @return [Hash{Symbol => Object}] including :current_version, :status_code and :status_time
+    def status_info
+      status_code = 0
+      status_time = nil
+      # for each milestone in the current version, see if it comes after the current 'last' step, if so, make it the last and record the date/time
+      current_milestones.each do |m|
+        m_name = m[:milestone]
+        m_time = m[:at].utc.xmlschema
+        next unless STEPS.key?(m_name) && (!status_time || m_time > status_time)
+
+        status_code = STEPS[m_name]
+        status_time = m_time
+      end
+
+      { current_version: current_version, status_code: status_code, status_time: status_time }
+    end
+
+    # @param [Boolean] include_time
+    # @return [String] single composed status from status_info
+    def status(include_time = false)
+      status_info_hash = status_info
+      current_version = status_info_hash[:current_version]
+      status_code = status_info_hash[:status_code]
+      status_time = status_info_hash[:status_time]
+
+      # use the translation table to get the appropriate verbage for the latest step
+      result = "v#{current_version} #{STATUS_CODE_DISP_TXT[status_code]}"
+      result += " #{format_date(status_time)}" if include_time
+      result
+    end
+
+    def milestones
+      @milestones ||= Dor::Config.workflow.client.get_milestones('dor', work.pid)
+    end
+
+    private
+
+    attr_reader :work
+
+    def current_version
+      @current_version ||= begin
+                             work.versionMetadata.current_version_id
+                           rescue StandardError
+                             '1'
+                           end
+    end
+
+    def current_milestones
+      current = []
+      # only get steps that are part of accessioning and part of the current version. That can mean they were archived with the current version
+      # number, or they might be active (no version number).
+      milestones.each do |m|
+        if STEPS.key?(m[:milestone]) && (m[:version].nil? || m[:version] == current_version)
+          current << m unless m[:milestone] == 'registered' && current_version.to_i > 1
+        end
+      end
+      current
+    end
+
+    # handles formating utc date/time to human readable
+    # XXX: bad form to hardcode TZ here.
+    def format_date(datetime)
+      d =
+        if datetime.is_a?(Time)
+          datetime
+        else
+          DateTime.parse(datetime).in_time_zone(ActiveSupport::TimeZone.new('Pacific Time (US & Canada)'))
+        end
+      I18n.l(d).strftime('%Y-%m-%d %I:%M%p')
+    rescue StandardError
+      d = datetime.is_a?(Time) ? datetime : Time.parse(datetime.to_s)
+      d.strftime('%Y-%m-%d %I:%M%p')
+    end
+  end
+end

data/lib/dor/services/suri_service.rb

@@ -15,18 +15,16 @@ module Dor
       if Config.suri.mint_ids
         # Post with no body
         resource = RestClient::Resource.new("#{Config.suri.url}/suri2/namespaces/#{Config.suri.id_namespace}",
-                                            :user => Config.suri.user, :password => Config.suri.pass)
+                                            user: Config.suri.user, password: Config.suri.pass)
         ids = resource["identifiers?quantity=#{quantity}"].post('').chomp.split(/\n/).collect { |id| "#{Config.suri.id_namespace}:#{id.strip}" }
       else
         repo = ActiveFedora::Base.respond_to?(:connection_for_pid) ? ActiveFedora::Base.connection_for_pid(0) : ActiveFedora.fedora.connection
         resp = Nokogiri::XML(repo.api.next_pid(numPIDs: quantity))
-        ids = resp.xpath('/pidList/pid').collect { |node| node.text }
+        ids = resp.xpath('/pidList/pid').collect(&:text)
         # With modernish (circa 2015/6) dependencies, including Nokogiri and
         # ActiveFedora/Rubydora, `ids` is `[]` above. If that is the case, try
         # the XPath that works (confirmed with most recent `hydra_etd` work)
-        if ids.empty? && resp.root.namespaces.any?
-          ids = resp.xpath('/xmlns:pidList/xmlns:pid').collect { |node| node.text }
-        end
+        ids = resp.xpath('/xmlns:pidList/xmlns:pid').collect(&:text) if ids.empty? && resp.root.namespaces.any?
       end
       want_array ? ids : ids.first
 

data/lib/dor/services/tag_service.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Dor
+  # Manage tags on an object
+  class TagService
+    def self.add(item, tag)
+      new(item).add(tag)
+    end
+
+    def self.remove(item, tag)
+      new(item).remove(tag)
+    end
+
+    def self.update(item, old_tag, new_tag)
+      new(item).update(old_tag, new_tag)
+    end
+
+    def initialize(item)
+      @item = item
+    end
+
+    # Add an administrative tag to an item, you will need to seperately save the item to write it to fedora
+    # @param tag [string] The tag you wish to add
+    def add(tag)
+      normalized_tag = validate_and_normalize_tag(tag, identity_metadata.tags)
+      identity_metadata.add_value(:tag, normalized_tag)
+    end
+
+    def remove(tag)
+      normtag = normalize_tag(tag)
+      tag_nodes
+        .select { |node| normalize_tag(node.content) == normtag }
+        .each { identity_metadata.ng_xml_will_change! }
+        .each(&:remove)
+        .any?
+    end
+
+    def update(old_tag, new_tag)
+      normtag = normalize_tag(old_tag)
+      tag_nodes
+        .select { |node| normalize_tag(node.content) == normtag }
+        .each { identity_metadata.ng_xml_will_change! }
+        .each { |node| node.content = normalize_tag(new_tag) }
+        .any?
+    end
+
+    private
+
+    attr_reader :item
+    def identity_metadata
+      item.identityMetadata
+    end
+
+    def tag_nodes
+      identity_metadata.ng_xml.search('//tag')
+    end
+
+    # turns a tag string into an array with one element per tag part.
+    # split on ":", disregard leading and trailing whitespace on tokens.
+    def split_tag_to_arr(tag_str)
+      tag_str.split(':').map(&:strip)
+    end
+
+    # turn a tag array back into a tag string with a standard format
+    def normalize_tag_arr(tag_arr)
+      tag_arr.join(' : ')
+    end
+
+    # take a tag string and return a normalized tag string
+    def normalize_tag(tag_str)
+      normalize_tag_arr(split_tag_to_arr(tag_str))
+    end
+
+    # take a proposed tag string and a list of the existing tags for the object being edited.  if
+    # the proposed tag is valid, return it in normalized form.  if not, raise an exception with an
+    # explanatory message.
+    def validate_and_normalize_tag(tag_str, existing_tag_list)
+      tag_arr = validate_tag_format(tag_str)
+
+      # note that the comparison for duplicate tags is case-insensitive, but we don't change case as part of the normalized version
+      # we return, because we want to preserve the user's intended case.
+      normalized_tag = normalize_tag_arr(tag_arr)
+      dupe_existing_tag = existing_tag_list.detect { |existing_tag| normalize_tag(existing_tag).casecmp(normalized_tag) == 0 }
+      raise "An existing tag (#{dupe_existing_tag}) is the same, consider using update_tag?" if dupe_existing_tag
+
+      normalized_tag
+    end
+
+    # Ensure that an administrative tag meets the proper mininum format
+    # @param tag_str [String] the tag
+    # @return [Array] the tag split into an array via ':'
+    def validate_tag_format(tag_str)
+      tag_arr = split_tag_to_arr(tag_str)
+      raise ArgumentError, "Invalid tag structure: tag '#{tag_str}' must have at least 2 elements" if tag_arr.length < 2
+      raise ArgumentError, "Invalid tag structure: tag '#{tag_str}' contains empty elements" if tag_arr.detect(&:empty?)
+
+      tag_arr
+    end
+  end
+end

data/lib/dor/services/technical_metadata_service.rb

@@ -49,10 +49,11 @@ module Dor
     # @param [Dor::Item] dor_item The DOR item being processed by the technical metadata robot
     # @return [FileGroupDifference] The differences between two versions of a group of files
     def self.get_content_group_diff(dor_item)
-      inventory_diff = dor_item.get_content_diff('all')
+      return Moab::FileGroupDifference.new if dor_item.contentMetadata.nil?
+      raise Dor::ParameterError, 'Missing Dor::Config.stacks.local_workspace_root' if Config.stacks.local_workspace_root.nil?
+
+      inventory_diff = Sdr::Client.get_content_diff(dor_item.pid, dor_item.contentMetadata.content, 'all')
       inventory_diff.group_difference('content')
-    rescue Dor::Exception # no contentMetadata
-      Moab::FileGroupDifference.new
     end
 
     # @param [FileGroupDifference] content_group_diff
@@ -92,7 +93,7 @@ module Dor
     #   The data is updated to the latest format.
     def self.get_dor_technical_metadata(dor_item)
       ds = 'technicalMetadata'
-      return nil unless dor_item.datastreams.keys.include?(ds) && !dor_item.datastreams[ds].new?
+      return nil unless dor_item.datastreams.key?(ds) && !dor_item.datastreams[ds].new?
 
       dor_techmd = dor_item.datastreams[ds].content
       return dor_techmd if dor_techmd =~ /<technicalMetadata/

data/lib/dor/services/version_service.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Dor
+  # Open and close versions
+  class VersionService
+    def self.open(work, opts = {})
+      new(work).open(opts)
+    end
+
+    def self.close(work, opts = {})
+      new(work).close(opts)
+    end
+
+    def initialize(work)
+      @work = work
+    end
+
+    # Increments the version number and initializes versioningWF for the object
+    # @param [Hash] opts optional params
+    # @option opts [Boolean] :assume_accessioned If true, does not check whether object has been accessioned.
+    # @option opts [Boolean] :create_workflows_ds If false, create_workflow() will not initialize the workflows datastream.
+    # @option opts [Hash] :vers_md_upd_info If present, used to add to the events datastream and set the desc and significance on the versionMetadata datastream
+    # @raise [Dor::Exception] if the object hasn't been accessioned, or if a version is already opened
+    def open(opts = {})
+      # During local development, we need a way to open a new version even if the object has not been accessioned.
+      raise(Dor::Exception, 'Object net yet accessioned') unless
+        opts[:assume_accessioned] || Dor::Config.workflow.client.get_lifecycle('dor', work.pid, 'accessioned')
+      raise Dor::Exception, 'Object already opened for versioning' if open?
+      raise Dor::Exception, 'Object currently being accessioned' if Dor::Config.workflow.client.get_active_lifecycle('dor', work.pid, 'submitted')
+
+      sdr_version = Sdr::Client.current_version work.pid
+
+      vmd_ds = work.versionMetadata
+      vmd_ds.sync_then_increment_version sdr_version
+      vmd_ds.save unless work.new_record?
+
+      k = :create_workflows_ds
+      if opts.key?(k)
+        # During local development, Hydrus (or another app w/ local Fedora) does not want to initialize workflows datastream.
+        work.create_workflow('versioningWF', opts[k])
+      else
+        work.create_workflow('versioningWF')
+      end
+
+      vmd_upd_info = opts[:vers_md_upd_info]
+      return unless vmd_upd_info
+
+      work.events.add_event('open', vmd_upd_info[:opening_user_name], "Version #{vmd_ds.current_version_id} opened")
+      vmd_ds.update_current_version(description: vmd_upd_info[:description], significance: vmd_upd_info[:significance].to_sym)
+      work.save
+    end
+
+    # Sets versioningWF:submit-version to completed and initiates accessionWF for the object
+    # @param [Hash] opts optional params
+    # @option opts [String] :description describes the version change
+    # @option opts [Symbol] :significance which part of the version tag to increment
+    #  :major, :minor, :admin (see Dor::VersionTag#increment)
+    # @option opts [String] :version_num version number to archive rows with. Otherwise, current version is used
+    # @option opts [Boolean] :start_accesion set to true if you want accessioning to start (default), false otherwise
+    # @raise [Dor::Exception] if the object hasn't been opened for versioning, or if accessionWF has
+    #   already been instantiated or the current version is missing a tag or description
+    def close(opts = {})
+      unless opts.empty?
+        work.versionMetadata.update_current_version opts
+        work.versionMetadata.save
+      end
+
+      raise Dor::Exception, 'latest version in versionMetadata requires tag and description before it can be closed' unless work.versionMetadata.current_version_closeable?
+      raise Dor::Exception, 'Trying to close version on an object not opened for versioning' unless open?
+      raise Dor::Exception, 'accessionWF already created for versioned object' if Dor::Config.workflow.client.get_active_lifecycle('dor', work.pid, 'submitted')
+
+      Dor::Config.workflow.client.close_version 'dor', work.pid, opts.fetch(:start_accession, true) # Default to creating accessionWF when calling close_version
+    end
+
+    # @return [Boolean] true if 'opened' lifecycle is active, false otherwise
+    def open?
+      return true if Dor::Config.workflow.client.get_active_lifecycle('dor', work.pid, 'opened')
+
+      false
+    end
+
+    attr_reader :work
+  end
+end