dor_indexing 1.0.0

data/lib/dor_indexing/indexers/identifiable_indexer.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Indexers
+    # Indexes the identifiable concerns
+    class IdentifiableIndexer
+      attr_reader :cocina, :cocina_repository
+
+      CURRENT_CATALOG_TYPE = 'folio'
+
+      def initialize(cocina:, cocina_repository:, **)
+        @cocina = cocina
+        @cocina_repository = cocina_repository
+      end
+
+      ## Module-level variables, shared between ALL mixin includers (and ALL *their* includers/extenders)!
+      ## used for caching found values
+      @@apo_hash = {} # rubocop:disable Style/ClassVars
+
+      # @return [Hash] the partial solr document for identifiable concerns
+      def to_solr
+        {}.tap do |solr_doc|
+          add_apo_titles(solr_doc, cocina.administrative.hasAdminPolicy)
+
+          solr_doc['metadata_source_ssim'] = identity_metadata_sources unless cocina.is_a? Cocina::Models::AdminPolicyWithMetadata
+          # This used to be added to the index by https://github.com/sul-dlss/dor-services/commit/11b80d249d19326ef591411ffeb634900e75c2c3
+          # and was called dc_identifier_druid_tesim
+          # It is used to search based on druid.
+          solr_doc['objectId_tesim'] = [cocina.externalIdentifier, cocina.externalIdentifier.delete_prefix('druid:')]
+        end
+      end
+
+      # @return [Array<String>] calculated values for Solr index
+      def identity_metadata_sources
+        return ['DOR'] if !cocina.identification.respond_to?(:catalogLinks) || distinct_current_catalog_types.empty?
+
+        distinct_current_catalog_types.map(&:capitalize)
+      end
+
+      # Clears out the cache of items. Used primarily in testing.
+      def self.reset_cache!
+        @@apo_hash = {} # rubocop:disable Style/ClassVars
+      end
+
+      private
+
+      def distinct_current_catalog_types
+        # Filter out e.g. "previous symphony", "previous folio"
+        @distinct_current_catalog_types ||=
+          cocina.identification
+                .catalogLinks
+                .map(&:catalog)
+                .uniq
+                .sort
+                .select { |catalog_type| catalog_type == CURRENT_CATALOG_TYPE }
+      end
+
+      # @param [Hash] solr_doc
+      # @param [String] admin_policy_id
+      def add_apo_titles(solr_doc, admin_policy_id)
+        row = populate_cache(admin_policy_id)
+        title = row['related_obj_title']
+        if row['is_from_hydrus']
+          ::Solrizer.insert_field(solr_doc, 'hydrus_apo_title', title, :symbol)
+        else
+          ::Solrizer.insert_field(solr_doc, 'nonhydrus_apo_title', title, :symbol)
+        end
+        ::Solrizer.insert_field(solr_doc, 'apo_title', title, :symbol)
+      end
+
+      # populate cache if necessary
+      def populate_cache(rel_druid)
+        @@apo_hash[rel_druid] ||= begin
+          related_obj = cocina_repository.find(rel_druid)
+          # APOs don't have projects, and since Hydrus is set to be retired, I don't want to
+          # add the cocina property. Just check the tags service instead.
+          is_from_hydrus = hydrus_tag?(rel_druid)
+          title = Cocina::Models::Builders::TitleBuilder.build(related_obj.description.title)
+          { 'related_obj_title' => title, 'is_from_hydrus' => is_from_hydrus }
+        rescue CocinaRepository::RepositoryError
+          Honeybadger.notify("Bad association found on #{cocina.externalIdentifier}. #{rel_druid} could not be found")
+          # This may happen if the given APO or Collection does not exist (bad data)
+          { 'related_obj_title' => rel_druid, 'is_from_hydrus' => false }
+        end
+      end
+
+      def hydrus_tag?(id)
+        cocina_repository.administrative_tags(id).include?('Project : Hydrus')
+      end
+    end
+  end
+end

data/lib/dor_indexing/indexers/identity_metadata_indexer.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Indexers
+    # Indexes the identity metadata
+    class IdentityMetadataIndexer
+      attr_reader :cocina_object
+
+      def initialize(cocina:, **)
+        @cocina_object = cocina
+      end
+
+      # @return [Hash] the partial solr document for identityMetadata
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def to_solr
+        return { 'objectType_ssim' => [object_type] } if object_type == 'adminPolicy' || cocina_object.identification.nil?
+
+        {
+          'objectType_ssim' => [object_type],
+          'dor_id_tesim' => [source_id_value, barcode, folio_instance_hrid, previous_ils_ids].flatten.compact,
+          'identifier_ssim' => prefixed_identifiers,
+          'identifier_tesim' => prefixed_identifiers,
+          'barcode_id_ssim' => [barcode].compact,
+          'source_id_ssi' => source_id,
+          'source_id_text_nostem_i' => source_id,
+          'folio_instance_hrid_ssim' => [folio_instance_hrid].compact,
+          'doi_ssim' => [doi].compact
+        }
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def source_id
+        @source_id ||= cocina_object.identification.sourceId
+      end
+
+      def source_id_value
+        @source_id_value ||= source_id ? source_id.split(':', 2)[1] : nil
+      end
+
+      def barcode
+        @barcode ||= object_type == 'collection' ? nil : cocina_object.identification.barcode
+      end
+
+      def doi
+        @doi ||= object_type == 'item' ? cocina_object.identification.doi : nil
+      end
+
+      def folio_instance_hrid
+        @folio_instance_hrid ||= Array(cocina_object.identification.catalogLinks).find { |link| link.catalog == 'folio' }&.catalogRecordId
+      end
+
+      def previous_folio_instance_hrids
+        @previous_folio_instance_hrids ||=
+          Array(cocina_object.identification.catalogLinks).filter_map { |link| link.catalogRecordId if link.catalog == 'previous folio' }
+      end
+
+      def previous_ils_ids
+        @previous_ils_ids ||= previous_folio_instance_hrids
+      end
+
+      def object_type
+        case cocina_object
+        when Cocina::Models::AdminPolicyWithMetadata
+          'adminPolicy'
+        when Cocina::Models::CollectionWithMetadata
+          'collection'
+        else
+          cocina_object.type == Cocina::Models::ObjectType.agreement ? 'agreement' : 'item'
+        end
+      end
+
+      def prefixed_identifiers
+        [].tap do |identifiers|
+          identifiers << source_id if source_id
+          identifiers << "barcode:#{barcode}" if barcode
+          identifiers << "folio:#{folio_instance_hrid}" if folio_instance_hrid
+        end
+      end
+    end
+  end
+end

data/lib/dor_indexing/indexers/process_indexer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Indexers
+    # Indexes the process for a workflow
+    class ProcessIndexer
+      ERROR_OMISSION = '... (continued)'
+      private_constant :ERROR_OMISSION
+
+      # see https://lucene.apache.org/core/7_3_1/core/org/apache/lucene/util/BytesRefHash.MaxBytesLengthExceededException.html
+      MAX_ERROR_LENGTH = 32_768 - 2 - ERROR_OMISSION.length
+      private_constant :MAX_ERROR_LENGTH
+
+      # @param [WorkflowSolrDocument] solr_doc
+      # @param [String] workflow_name
+      # @param [Dor::Workflow::Response::Process] process
+      def initialize(solr_doc:, workflow_name:, process:)
+        @solr_doc = solr_doc
+        @workflow_name = workflow_name
+        @process = process
+      end
+
+      # @return [Hash] the partial solr document for the workflow document
+      # rubocop:disable Metrics/AbcSize
+      def to_solr
+        return unless status
+
+        # add a record of the robot having operated on this item, so we can track robot activity
+        solr_doc.add_process_time(workflow_name, name, Time.parse(process.datetime)) if time?
+
+        index_error_message
+
+        # workflow name, process status then process name
+        solr_doc.add_wsp("#{workflow_name}:#{status}", "#{workflow_name}:#{status}:#{name}")
+
+        # workflow name, process name then process status
+        solr_doc.add_wps("#{workflow_name}:#{name}", "#{workflow_name}:#{name}:#{status}")
+
+        # process status, workflowname then process name
+        solr_doc.add_swp(process.status.to_s, "#{status}:#{workflow_name}", "#{status}:#{workflow_name}:#{name}")
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      attr_reader :process, :workflow_name, :solr_doc
+
+      delegate :status, :name, :state, :error_message, :datetime, to: :process
+
+      def time?
+        datetime && (status == 'completed' || status == 'error')
+      end
+
+      # index the error message without the druid so we hopefully get some overlap
+      # truncate to avoid org.apache.lucene.util.BytesRefHash$MaxBytesLengthExceededException
+      def index_error_message
+        return unless error_message
+
+        solr_doc.error = "#{workflow_name}:#{name}:#{error_message}".truncate(MAX_ERROR_LENGTH, omission: ERROR_OMISSION)
+      end
+    end
+  end
+end

data/lib/dor_indexing/indexers/releasable_indexer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Indexers
+    # Indexes the object's release tags
+    class ReleasableIndexer
+      attr_reader :cocina, :parent_collections
+
+      def initialize(cocina:, parent_collections:, **)
+        @cocina = cocina
+        @parent_collections = parent_collections
+      end
+
+      # @return [Hash] the partial solr document for releasable concerns
+      def to_solr
+        return {} if tags.blank?
+
+        {
+          'released_to_ssim' => tags.map(&:to).uniq,
+          'released_to_searchworks_dttsi' => searchworks_release_date,
+          'released_to_earthworks_dttsi' => earthworks_release_date
+        }.compact
+      end
+
+      private
+
+      def earthworks_release_date
+        tags.find { |tag| tag.to == 'Earthworks' }&.date&.utc&.iso8601
+      end
+
+      def searchworks_release_date
+        tags.find { |tag| tag.to == 'Searchworks' }&.date&.utc&.iso8601
+      end
+
+      # Item tags have precidence over collection tags, so if the collection is release=true
+      # and the item is release=false, then it is not released
+      def tags
+        @tags ||= tags_from_collection.merge(tags_from_item).values.select(&:release)
+      end
+
+      def tags_from_collection
+        parent_collections.each_with_object({}) do |collection, result|
+          Array(collection.administrative.releaseTags)
+            .select { |tag| tag.what == 'collection' }
+            .group_by(&:to).map do |project, releases_for_project|
+              result[project] = releases_for_project.max_by(&:date)
+            end
+        end
+      end
+
+      def tags_from_item
+        released_for.group_by(&:to).transform_values do |releases_for_project|
+          releases_for_project.max_by(&:date)
+        end
+      end
+
+      def released_for
+        Array(cocina.administrative.releaseTags)
+      end
+    end
+  end
+end

data/lib/dor_indexing/indexers/rights_metadata_indexer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Indexers
+    # Indexes the rights metadata
+    class RightsMetadataIndexer
+      attr_reader :cocina
+
+      def initialize(cocina:, **)
+        @cocina = cocina
+      end
+
+      # @return [Hash] the partial solr document for rightsMetadata
+      def to_solr
+        {
+          'copyright_ssim' => cocina.access.copyright,
+          'use_statement_ssim' => cocina.access.useAndReproductionStatement,
+          'use_license_machine_ssi' => license,
+          'rights_descriptions_ssim' => rights_description
+        }.compact
+      end
+
+      private
+
+      LICENSE_CODE = {
+        'http://cocina.sul.stanford.edu/licenses/none' => 'none', # Only used in some legacy ETDs.
+        'https://creativecommons.org/licenses/by/3.0/legalcode' => 'CC-BY-3.0',
+        'https://creativecommons.org/licenses/by-sa/3.0/legalcode' => 'CC-BY-SA-3.0',
+        'https://creativecommons.org/licenses/by-nd/3.0/legalcode' => 'CC-BY-ND-3.0',
+        'https://creativecommons.org/licenses/by-nc/3.0/legalcode' => 'CC-BY-NC-3.0',
+        'https://creativecommons.org/licenses/by-nc-sa/3.0/legalcode' => 'CC-BY-NC-SA-3.0',
+        'https://creativecommons.org/licenses/by-nc-nd/3.0/legalcode' => 'CC-BY-NC-ND-3.0',
+        'https://creativecommons.org/licenses/by/4.0/legalcode' => 'CC-BY-4.0',
+        'https://creativecommons.org/licenses/by-sa/4.0/legalcode' => 'CC-BY-SA-4.0',
+        'https://creativecommons.org/licenses/by-nd/4.0/legalcode' => 'CC-BY-ND-4.0',
+        'https://creativecommons.org/licenses/by-nc/4.0/legalcode' => 'CC-BY-NC-4.0',
+        'https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode' => 'CC-BY-NC-SA-4.0',
+        'https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode' => 'CC-BY-NC-ND-4.0',
+        'https://creativecommons.org/publicdomain/zero/1.0/legalcode' => 'CC0-1.0',
+        'https://creativecommons.org/publicdomain/mark/1.0/' => 'PDM',
+        'https://opendatacommons.org/licenses/pddl/1-0/' => 'PDDL-1.0',
+        'https://opendatacommons.org/licenses/by/1-0/' => 'ODC-By-1.0',
+        'https://opendatacommons.org/licenses/odbl/1-0/' => 'ODbL-1.0'
+      }.freeze
+
+      def rights_description
+        return DorIndexing::Builders::CollectionRightsDescriptionBuilder.build(cocina) if cocina.collection?
+
+        Cocina::Models::Builders::DroRightsDescriptionBuilder.build(cocina)
+      end
+
+      # @return [String] the code if we've defined one, or the URI if we haven't.
+      def license
+        uri = cocina.access.license
+        LICENSE_CODE.fetch(uri, uri)
+      end
+    end
+  end
+end

data/lib/dor_indexing/indexers/role_metadata_indexer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Indexers
+    # Indexes the role metadata
+    class RoleMetadataIndexer
+      attr_reader :cocina
+
+      def initialize(cocina:, **)
+        @cocina = cocina
+      end
+
+      # @return [Hash] the partial solr document for roleMetadata
+      # rubocop:disable Metrics/AbcSize
+      def to_solr
+        Array(cocina.administrative.roles).each_with_object({}) do |role, solr_doc|
+          solr_doc['apo_register_permissions_ssim'] = serialize(role.members) if role.name == 'dor-apo-manager'
+          solr_doc["apo_role_#{role.name}_ssim"] = serialize(role.members.select { |member| member.type == 'workgroup' })
+          solr_doc["apo_role_person_#{role.name}_ssim"] = serialize(role.members.select { |member| member.type == 'sunetid' })
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      def serialize(members)
+        members.map { |member| [member.type, member.identifier].join(':') }
+      end
+    end
+  end
+end

data/lib/dor_indexing/indexers/workflow_indexer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Indexers
+    # Indexes the objects position in workflows
+    class WorkflowIndexer
+      # @param [Workflow::Response::Workflow] workflow the workflow document to index
+      def initialize(workflow:, workflow_client:)
+        @workflow = workflow
+        @workflow_client = workflow_client
+      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:, workflow_name:, process:).to_solr
+            errors += 1 if process.status == 'error'
+          end
+          solr_doc.status = [workflow_name, workflow_status, errors].join('|')
+        end
+      end
+
+      private
+
+      attr_reader :workflow, :workflow_client
+
+      delegate :workflow_name, to: :workflow
+
+      def definition_process_names
+        @definition_process_names ||= begin
+          definition = workflow_client.workflow_template(workflow_name)
+          definition['processes'].pluck('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
+end

data/lib/dor_indexing/indexers/workflows_indexer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Indexers
+    # Indexes the objects position in workflows
+    class WorkflowsIndexer
+      attr_reader :id
+
+      def initialize(id:, workflow_client:, **)
+        @id = id
+        @workflow_client = workflow_client
+      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, workflow_client:).to_solr
+            combined_doc.merge!(doc)
+          end
+        end.to_h
+      end
+
+      private
+
+      attr_reader :workflow_client
+
+      # @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 ||= workflow_client.workflow_routes.all_workflows pid: id
+      end
+    end
+  end
+end