dor-services 8.6.0 → 9.0.0

data/lib/dor/indexers/processable_indexer.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  class ProcessableIndexer
-    include SolrDocHelper
-
-    attr_reader :resource
-    def initialize(resource:)
-      @resource = resource
-      @status_service = StatusService.new(resource)
-    end
-
-    # @return [Hash] the partial solr document for processable concerns
-    def to_solr
-      {}.tap do |solr_doc|
-        add_versions(solr_doc)
-        add_milestones(solr_doc)
-        solr_doc['modified_latest_dttsi'] = resource.modified_date.to_datetime.utc.strftime('%FT%TZ')
-        add_solr_value(solr_doc, 'rights', resource.rights, :string, [:symbol]) if resource.respond_to? :rights
-        add_status(solr_doc)
-      end
-    end
-
-    private
-
-    attr_reader :status_service
-
-    def current_version
-      @current_version ||= begin
-                             resource.current_version
-                           rescue StandardError
-                             '1'
-                           end
-    end
-
-    def add_status(solr_doc)
-      solr_doc['status_ssi'] = status_service.status # status is singular (i.e. the current one)
-      status_info_hash = status_service.status_info
-      status_code = status_info_hash[:status_code]
-      add_solr_value(solr_doc, 'processing_status_text', simplified_status_code_disp_txt(status_code), :string, [:stored_sortable])
-      solr_doc['processing_status_code_isi'] = status_code
-    end
-
-    def add_milestones(solr_doc)
-      status_service.milestones.each do |milestone|
-        timestamp = milestone[:at].utc.xmlschema
-        milestone[:version] ||= current_version
-        solr_doc['lifecycle_ssim'] ||= []
-        solr_doc['lifecycle_ssim'] << milestone[:milestone]
-        add_solr_value(solr_doc, 'lifecycle', "#{milestone[:milestone]}:#{timestamp};#{milestone[:version]}", :symbol)
-      end
-
-      add_sortable_milestones(solr_doc)
-    end
-
-    def sortable_milestones
-      sortable = {}
-      status_service.milestones.each do |milestone|
-        sortable[milestone[:milestone]] ||= []
-        sortable[milestone[:milestone]] << milestone[:at].utc.xmlschema
-      end
-      sortable
-    end
-
-    def add_sortable_milestones(solr_doc)
-      sortable_milestones.each do |milestone, unordered_dates|
-        dates = unordered_dates.sort
-        # create the published_dttsi and published_day fields and the like
-        dates.each do |date|
-          solr_doc["#{milestone}_dttsim"] ||= []
-          solr_doc["#{milestone}_dttsim"] << date unless solr_doc["#{milestone}_dttsim"].include?(date)
-        end
-        # fields for OAI havester to sort on: _dttsi is trie date +stored +indexed (single valued, i.e. sortable)
-        solr_doc["#{milestone}_earliest_dttsi"] = dates.first
-        solr_doc["#{milestone}_latest_dttsi"] = dates.last
-      end
-    end
-
-    def add_versions(solr_doc)
-      current_version_num = current_version.to_i
-      solr_doc['current_version_isi'] = current_version_num
-
-      return unless resource.respond_to?('versionMetadata')
-
-      # add an entry with version id, tag and description for each version
-      while current_version_num > 0
-        new_val = "#{current_version_num};#{resource.versionMetadata.tag_for_version(current_version_num.to_s)};#{resource.versionMetadata.description_for_version(current_version_num.to_s)}"
-        add_solr_value(solr_doc, 'versions', new_val, :string, [:displayable])
-        current_version_num -= 1
-      end
-    end
-
-    # @return [String] text translation of the status code, minus any trailing parenthetical explanation
-    # e.g. 'In accessioning (described)' and 'In accessioning (described, published)' both return 'In accessioning'
-    def simplified_status_code_disp_txt(status_code)
-      StatusService::STATUS_CODE_DISP_TXT[status_code].gsub(/\(.*\)$/, '').strip
-    end
-  end
-end

data/lib/dor/indexers/releasable_indexer.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  class ReleasableIndexer
-    include SolrDocHelper
-
-    attr_reader :resource
-    def initialize(resource:)
-      @resource = resource
-    end
-
-    # @return [Hash] the partial solr document for releasable concerns
-    def to_solr
-      solr_doc = {}
-      # TODO: sort of worried about the performance impact in bulk reindex
-      # situations, since released_for recurses all parent collections.  jmartin 2015-07-14
-      released_for.each do |release_target, release_info|
-        add_solr_value(solr_doc, 'released_to', release_target, :symbol, []) if release_info['release']
-      end
-
-      # TODO: need to solrize whether item is released to purl?  does released_for return that?
-      # logic is: "True when there is a published lifecycle and Access Rights is anything but Dark"
-
-      solr_doc
-    end
-
-    private
-
-    def released_for
-      ReleaseTagService.for(resource).released_for(skip_live_purl: true)
-    end
-  end
-end

data/lib/dor/indexers/workflow_indexer.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  # Indexes the objects position in workflows
-  class WorkflowIndexer
-    # @param [Workflow::Response::Workflow] workflow the workflow document to index
-    def initialize(workflow:)
-      @workflow = workflow
-    end
-
-    # @return [Hash] the partial solr document for the workflow document
-    def to_solr
-      WorkflowSolrDocument.new do |solr_doc|
-        solr_doc.name = workflow_name
-
-        errors = 0 # The error count is used by the Report class in Argo
-        processes.each do |process|
-          ProcessIndexer.new(solr_doc: solr_doc, workflow_name: workflow_name, process: process).to_solr
-          errors += 1 if process.status == 'error'
-        end
-        solr_doc.status = [workflow_name, workflow_status, errors, repository].join('|')
-      end
-    end
-
-    private
-
-    attr_reader :workflow
-    delegate :workflow_name, :repository, to: :workflow
-
-    def definition_process_names
-      @definition_process_names ||= begin
-        definition = Dor::Config.workflow.client.workflow_template(workflow_name)
-        definition['processes'].map { |p| p['name'] }
-      end
-    end
-
-    def processes
-      @processes ||= definition_process_names.map do |process_name|
-        workflow.process_for_recent_version(name: process_name)
-      end
-    end
-
-    def workflow_status
-      workflow.complete? ? 'completed' : 'active'
-    end
-  end
-end

data/lib/dor/indexers/workflows_indexer.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  # Indexes the objects position in workflows
-  class WorkflowsIndexer
-    attr_reader :resource
-    def initialize(resource:)
-      @resource = resource
-    end
-
-    # @return [Hash] the partial solr document for workflow concerns
-    def to_solr
-      WorkflowSolrDocument.new do |combined_doc|
-        workflows.each do |wf|
-          doc = WorkflowIndexer.new(workflow: wf).to_solr
-          combined_doc.merge!(doc)
-        end
-      end.to_h
-    end
-
-    private
-
-    # @return [Array<Workflow::Response::Workflow>]
-    def workflows
-      all_workflows.workflows
-    end
-
-    # TODO: remove Dor::Workflow::Document
-    # @return [Workflow::Response::Workflows]
-    def all_workflows
-      @all_workflows ||= Dor::Config.workflow.client.workflow_routes.all_workflows pid: resource.pid
-    end
-  end
-end

data/lib/dor/models/workflow_object.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'dor/datastreams/workflow_definition_ds'
-
-module Dor
-  # @deprecated
-  class WorkflowObject < Dor::Abstract
-    has_object_type 'workflow'
-    has_metadata name: 'workflowDefinition', type: Dor::WorkflowDefinitionDs, label: 'Workflow Definition'
-
-    self.resource_indexer = CompositeIndexer.new(
-      DataIndexer,
-      DescribableIndexer,
-      IdentifiableIndexer,
-      ProcessableIndexer,
-      WorkflowsIndexer
-    )
-
-    def self.find_by_name(name)
-      Dor::WorkflowObject.where(Solrizer.solr_name('workflow_name', :symbol) => name).first
-    end
-
-    # @return [Dor::WorkflowDefinitionDs]
-    def definition
-      datastreams['workflowDefinition']
-    end
-  end
-end

data/lib/dor/models/workflow_solr_document.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  # Represents that part of the solr document that holds workflow data
-  class WorkflowSolrDocument
-    WORKFLOW_SOLR = 'wf_ssim'
-    # field that indexes workflow name, process status then process name
-    WORKFLOW_WPS_SOLR = 'wf_wps_ssim'
-    # field that indexes workflow name, process name then process status
-    WORKFLOW_WSP_SOLR = 'wf_wsp_ssim'
-    # field that indexes process status, workflowname then process name
-    WORKFLOW_SWP_SOLR = 'wf_swp_ssim'
-    WORKFLOW_ERROR_SOLR = 'wf_error_ssim'
-    WORKFLOW_STATUS_SOLR = 'workflow_status_ssim'
-
-    KEYS_TO_MERGE = [
-      WORKFLOW_SOLR,
-      WORKFLOW_WPS_SOLR,
-      WORKFLOW_WSP_SOLR,
-      WORKFLOW_SWP_SOLR,
-      WORKFLOW_STATUS_SOLR,
-      WORKFLOW_ERROR_SOLR
-    ].freeze
-
-    def initialize
-      @data = empty_document
-      yield self if block_given?
-    end
-
-    def name=(wf_name)
-      data[WORKFLOW_SOLR] += [wf_name]
-      data[WORKFLOW_WPS_SOLR] += [wf_name]
-      data[WORKFLOW_WSP_SOLR] += [wf_name]
-    end
-
-    def status=(status)
-      data[WORKFLOW_STATUS_SOLR] += [status]
-    end
-
-    def error=(message)
-      data[WORKFLOW_ERROR_SOLR] += [message]
-    end
-
-    # Add to the field that indexes workflow name, process status then process name
-    def add_wps(*messages)
-      data[WORKFLOW_WPS_SOLR] += messages
-    end
-
-    # Add to the field that indexes workflow name, process name then process status
-    def add_wsp(*messages)
-      data[WORKFLOW_WSP_SOLR] += messages
-    end
-
-    # Add to the field that indexes process status, workflow name then process name
-    def add_swp(*messages)
-      data[WORKFLOW_SWP_SOLR] += messages
-    end
-
-    # Add the processes data_time attribute to the solr document
-    # @param [String] wf_name
-    # @param [String] process_name
-    # @param [Time] time
-    def add_process_time(wf_name, process_name, time)
-      data["wf_#{wf_name}_#{process_name}_dttsi"] = time.utc.iso8601
-    end
-
-    def to_h
-      KEYS_TO_MERGE.each { |k| data[k].uniq! }
-      data
-    end
-
-    delegate :except, :[], to: :data
-
-    # @param [WorkflowSolrDocument] doc
-    def merge!(doc)
-      # This is going to get the date fields, e.g. `wf_assemblyWF_jp2-create_dttsi'
-      @data.merge!(doc.except(*KEYS_TO_MERGE))
-
-      # Combine the non-unique fields together
-      KEYS_TO_MERGE.each do |k|
-        data[k] += doc[k]
-      end
-    end
-
-    private
-
-    attr_reader :data
-
-    def empty_document
-      KEYS_TO_MERGE.each_with_object({}) { |k, obj| obj[k] = [] }
-    end
-  end
-end

data/lib/dor/release_tags.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  module ReleaseTags
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload :PurlClient
-      autoload :Purl
-      autoload :IdentityMetadata
-    end
-  end
-end

data/lib/dor/release_tags/identity_metadata.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  module ReleaseTags
-    class IdentityMetadata
-      # Determine projects in which an item is released
-      # @param [Dor::Item] item to get the release tags for
-      # @return [Hash{String => Boolean}] all namespaces, keys are Project name Strings, values are Boolean
-      def self.for(item)
-        new(item)
-      end
-
-      def initialize(item)
-        @item = item
-      end
-
-      # Called in Dor::UpdateMarcRecordService (in dor-services-app too)
-      # Determine projects in which an item is released
-      # @param [Hash{String => Boolean}] the released hash to add tags to
-      # @return [Hash{String => Boolean}] all namespaces, keys are Project name Strings, values are Boolean
-      def released_for(released_hash)
-        # Get the most recent self tag for all targets and retain their result since most recent self always trumps any other non self tags
-        latest_self_tags = newest_release_tag self_release_tags(release_tags)
-        latest_self_tags.each do |key, payload|
-          released_hash[key] = { 'release' => payload['release'] }
-        end
-
-        # With Self Tags resolved we now need to deal with tags on all sets this object is part of.
-        # Get all release tags on the item and strip out the what = self ones, we've already processed all the self tags on this item.
-        # This will be where we store all tags that apply, regardless of their timestamp:
-        potential_applicable_release_tags = tags_for_what_value(release_tags_for_item_and_all_governing_sets, 'collection')
-        administrative_tags = item.tags # Get admin tags once here and pass them down
-
-        # We now have the keys for all potential releases, we need to check the tags: the most recent timestamp with an explicit true or false wins.
-        # In a nil case, the lack of an explicit false tag we do nothing.
-        # Don't bother checking if already added to the release hash, they were added due to a self tag so that has won
-        (potential_applicable_release_tags.keys - released_hash.keys).each do |key|
-          latest_tag = latest_applicable_release_tag_in_array(potential_applicable_release_tags[key], administrative_tags)
-          next if latest_tag.nil? # Otherwise, we have a valid tag, record it
-
-          released_hash[key] = { 'release' => latest_tag['release'] }
-        end
-        released_hash
-      end
-
-      # Take an item and get all of its release tags and all tags on collections it is a member of it
-      # @return [Hash] a hash of all tags
-      def release_tags_for_item_and_all_governing_sets
-        return_tags = release_tags || {}
-        item.collections.each do |collection|
-          next if collection.id == item.id # recursive, so parents of parents are found, but we need to avoid an infinite loop if the collection references itself (i.e. bad data)
-
-          release_service = self.class.for(collection)
-          return_tags = combine_two_release_tag_hashes(return_tags, release_service.release_tags_for_item_and_all_governing_sets)
-        end
-        return_tags
-      end
-
-      # Take a hash of tags as obtained via Dor::Item.release_tags and returns the newest tag for each namespace
-      # @param tags [Hash] a hash of tags obtained via Dor::Item.release_tags or matching format
-      # @return [Hash] a hash of latest tags for each to value
-      def newest_release_tag(tags)
-        Hash[tags.map { |key, val| [key, newest_release_tag_in_an_array(val)] }]
-      end
-
-      private
-
-      delegate :release_tags, to: :item
-
-      # Take a hash of tags as obtained via Dor::Item.release_tags and returns all self tags
-      # @param tags [Hash] a hash of tags obtained via Dor::Item.release_tags or matching format
-      # @return [Hash] a hash of self tags for each to value
-      def self_release_tags(tags)
-        tags_for_what_value(tags, 'self')
-      end
-
-      # Take a hash of tags and return all tags with the matching what target
-      # @param tags [Hash] a hash of tags obtained via Dor::Item.release_tags or matching format
-      # @param what_target [String] the target for the 'what' key, self or collection
-      # @return [Hash] a hash of self tags for each to value
-      def tags_for_what_value(tags, what_target)
-        return_hash = {}
-        tags.keys.each do |key|
-          self_tags = tags[key].select { |tag| tag['what'].casecmp(what_target) == 0 }
-          return_hash[key] = self_tags unless self_tags.empty?
-        end
-        return_hash
-      end
-
-      # Take two hashes of tags and combine them, will not overwrite but will enforce uniqueness of the tags
-      # @param hash_one [Hash] a hash of tags obtained via Dor::Item.release_tags or matching format
-      # @param hash_two [Hash] a hash of tags obtained via Dor::Item.release_tags or matching format
-      # @return [Hash] the combined hash with uniquiness enforced
-      def combine_two_release_tag_hashes(hash_one, hash_two)
-        hash_two.keys.each do |key|
-          hash_one[key] = hash_two[key] if hash_one[key].nil?
-          hash_one[key] = (hash_one[key] + hash_two[key]).uniq unless hash_one[key].nil?
-        end
-        hash_one
-      end
-
-      # Takes an array of release tags and returns the most recent one
-      # @param array_of_tags [Array] an array of hashes, each hash a release tag
-      # @return [Hash] the most recent tag
-      def newest_release_tag_in_an_array(array_of_tags)
-        latest_tag_in_array = array_of_tags[0] || {}
-        array_of_tags.each do |tag|
-          latest_tag_in_array = tag if tag['when'] > latest_tag_in_array['when']
-        end
-        latest_tag_in_array
-      end
-
-      # Takes a tag and returns true or false if it applies to the specific item
-      # @param release_tag [Hash] the tag in a hashed form
-      # @param admin_tags [Array] the administrative tags on an item, if not supplied it will attempt to retrieve them
-      # @return [Boolean] true or false if it applies (not true or false if it is released, that is the release_tag data)
-      def does_release_tag_apply(release_tag, admin_tags = false)
-        # Is the tag global or restricted
-        return true if release_tag['tag'].nil? # no specific tag specificied means this tag is global to all members of the collection
-
-        admin_tags ||= item.tags # We use false instead of [], since an item can have no admin_tags at which point we'd be passing this var as [] and would not attempt to retrieve it
-        admin_tags.include?(release_tag['tag'])
-      end
-
-      # Takes an array of release tags and returns the most recent one that applies to this item
-      # @param release_tags [Array] an array of release tags in hashed form
-      # @param admin_tags [Array] the administrative tags on an on item
-      # @return [Hash] the tag, or nil if none applicable
-      def latest_applicable_release_tag_in_array(release_tags, admin_tags)
-        newest_tag = newest_release_tag_in_an_array(release_tags)
-        return newest_tag if does_release_tag_apply(newest_tag, admin_tags)
-
-        # The latest tag wasn't applicable, slice it off and try again
-        # This could be optimized by reordering on the timestamp and just running down it instead of constantly resorting, at least if we end up getting numerous release tags on an item
-        release_tags.slice!(release_tags.index(newest_tag))
-
-        return latest_applicable_release_tag_in_array(release_tags, admin_tags) unless release_tags.empty? # Try again after dropping the inapplicable
-
-        nil # We're out of tags, no applicable ones
-      end
-
-      attr_reader :item
-    end
-  end
-end