dor_indexing 1.0.0

data/lib/dor_indexing/builders/all_search_text_builder.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Builders
+    # Extracts useful text for searching from Cocina Description
+    class AllSearchTextBuilder
+      def self.build(cocina_description)
+        new(cocina_description).build
+      end
+
+      def initialize(cocina_description)
+        @cocina_description = cocina_description
+      end
+
+      def build
+        @text = []
+        recurse(cocina_description)
+        text.join(' ')
+      end
+
+      private
+
+      attr_reader :cocina_description, :text
+
+      # this originally had displayLabel, but Arcadia recommends against it
+      TEXT_KEYS = %i[
+        value
+      ].freeze
+
+      RECURSE_KEYS = %i[
+        structuredValue
+        parallelValue
+        groupedValue
+        title
+        contributor
+        event
+        form
+        language
+        note
+        relatedResource
+        subject
+        name
+        location
+      ].freeze
+
+      def recurse(desc)
+        TEXT_KEYS.each do |key|
+          value = desc.try(key)
+          text << value if value.present?
+        end
+
+        RECURSE_KEYS.each do |key|
+          Array(desc.try(key)).each { |value| recurse(value) }
+        end
+      end
+    end
+  end
+end

data/lib/dor_indexing/builders/author_builder.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Builders
+    # Builds the author fields for a solr document
+    class AuthorBuilder
+      def initialize(cocina_contributors)
+        @cocina_contributors = Array(cocina_contributors)
+      end
+
+      def build_primary
+        contributor = primary_cocina_contributor || cocina_contributors.first
+        return unless contributor
+
+        NameBuilder.build_primary_name(contributor.name) if contributor
+      end
+
+      def build_all
+        NameBuilder.build_all(cocina_contributors.filter_map(&:name))
+      end
+
+      private
+
+      attr_reader :cocina_contributors
+
+      def primary_cocina_contributor
+        cocina_contributors.find { |cocina_contributor| cocina_contributor.status == 'primary' }
+      end
+    end
+  end
+end

data/lib/dor_indexing/builders/collection_rights_description_builder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Builders
+    # Rights description builder for collections
+    class CollectionRightsDescriptionBuilder
+      def self.build(cocina)
+        new(cocina).build
+      end
+
+      def initialize(cocina)
+        @cocina = cocina
+      end
+
+      def build
+        case cocina.access.view
+        when 'world'
+          'world'
+        else
+          'dark'
+        end
+      end
+
+      private
+
+      attr_reader :cocina
+    end
+  end
+end

data/lib/dor_indexing/builders/document_builder.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Builders
+    # Builds solr document for indexing.
+    class DocumentBuilder
+      ADMIN_POLICY_INDEXER = DorIndexing::Indexers::CompositeIndexer.new(
+        DorIndexing::Indexers::AdministrativeTagIndexer,
+        DorIndexing::Indexers::DataIndexer,
+        DorIndexing::Indexers::RoleMetadataIndexer,
+        DorIndexing::Indexers::DefaultObjectRightsIndexer,
+        DorIndexing::Indexers::IdentityMetadataIndexer,
+        DorIndexing::Indexers::DescriptiveMetadataIndexer,
+        DorIndexing::Indexers::IdentifiableIndexer,
+        DorIndexing::Indexers::WorkflowsIndexer
+      )
+
+      COLLECTION_INDEXER = DorIndexing::Indexers::CompositeIndexer.new(
+        DorIndexing::Indexers::AdministrativeTagIndexer,
+        DorIndexing::Indexers::DataIndexer,
+        DorIndexing::Indexers::RightsMetadataIndexer,
+        DorIndexing::Indexers::IdentityMetadataIndexer,
+        DorIndexing::Indexers::DescriptiveMetadataIndexer,
+        DorIndexing::Indexers::IdentifiableIndexer,
+        DorIndexing::Indexers::ReleasableIndexer,
+        DorIndexing::Indexers::WorkflowsIndexer
+      )
+
+      ITEM_INDEXER = DorIndexing::Indexers::CompositeIndexer.new(
+        DorIndexing::Indexers::AdministrativeTagIndexer,
+        DorIndexing::Indexers::DataIndexer,
+        DorIndexing::Indexers::RightsMetadataIndexer,
+        DorIndexing::Indexers::IdentityMetadataIndexer,
+        DorIndexing::Indexers::DescriptiveMetadataIndexer,
+        DorIndexing::Indexers::EmbargoMetadataIndexer,
+        DorIndexing::Indexers::ContentMetadataIndexer,
+        DorIndexing::Indexers::IdentifiableIndexer,
+        DorIndexing::Indexers::CollectionTitleIndexer,
+        DorIndexing::Indexers::ReleasableIndexer,
+        DorIndexing::Indexers::WorkflowsIndexer
+      )
+
+      INDEXERS = {
+        Cocina::Models::ObjectType.agreement => ITEM_INDEXER, # Agreement uses same indexer as item
+        Cocina::Models::ObjectType.admin_policy => ADMIN_POLICY_INDEXER,
+        Cocina::Models::ObjectType.collection => COLLECTION_INDEXER
+      }.freeze
+
+      @@parent_collections = {} # rubocop:disable Style/ClassVars
+
+      def self.for(model:, workflow_client:, cocina_repository:)
+        new(model:, workflow_client:, cocina_repository:).for
+      end
+
+      def self.reset_parent_collections
+        @@parent_collections = {} # rubocop:disable Style/ClassVars
+      end
+
+      def initialize(model:, workflow_client:, cocina_repository:)
+        @model = model
+        @workflow_client = workflow_client
+        @cocina_repository = cocina_repository
+      end
+
+      # @param [Cocina::Models::DROWithMetadata,Cocina::Models::CollectionWithMetadata,Cocina::Model::AdminPolicyWithMetadata] model
+      def for
+        indexer_for_type(model.type).new(id:,
+                                         cocina: model,
+                                         parent_collections:,
+                                         administrative_tags:,
+                                         workflow_client:,
+                                         cocina_repository:)
+      end
+
+      private
+
+      attr_reader :model, :workflow_client, :cocina_repository
+
+      def id
+        model.externalIdentifier
+      end
+
+      def indexer_for_type(type)
+        INDEXERS.fetch(type, ITEM_INDEXER)
+      end
+
+      def parent_collections
+        return [] unless model.dro?
+
+        Array(model.structural&.isMemberOf).filter_map do |rel_druid|
+          @@parent_collections[rel_druid] ||= cocina_repository.find(rel_druid)
+        rescue DorIndexing::CocinaRepository::RepositoryError
+          Honeybadger.notify("Bad association found on #{model.externalIdentifier}. #{rel_druid} could not be found")
+          # This may happen if the referenced Collection does not exist (bad data)
+          nil
+        end
+      end
+
+      def administrative_tags
+        cocina_repository.administrative_tags(id)
+      rescue DorIndexing::CocinaRepository::RepositoryError
+        []
+      end
+    end
+  end
+end

data/lib/dor_indexing/builders/event_date_builder.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Builders
+    # Builds the event date fields for a solr document
+    class EventDateBuilder
+      # @param [Cocina::Models::Event] event single selected  event
+      # @return [String, nil] the date value for Solr
+      def self.build(event, date_type)
+        event_dates = Array(event&.date) + Array(event&.parallelEvent&.map(&:date))
+
+        matching_date_value_with_status_primary(event_dates, date_type) ||
+          matching_date_value(event_dates, date_type) ||
+          untyped_date_value(event_dates)
+      end
+
+      # @return [String, nil] date.value from a date of type of date_type and of status primary
+      def self.matching_date_value_with_status_primary(event_dates, date_type)
+        event_dates.flatten.compact.find do |date|
+          next if date.type != date_type
+
+          next unless DorIndexing::Selectors::EventSelector.date_status_primary(date)
+
+          return date_value(date)
+        end
+      end
+      private_class_method :matching_date_value_with_status_primary
+
+      # @return [String, nil] date.value from a date of type of date_type
+      def self.matching_date_value(event_dates, date_type)
+        event_dates.flatten.compact.find do |date|
+          next if date.type != date_type
+
+          return date_value(date)
+        end
+      end
+      private_class_method :matching_date_value
+
+      # @return [String, nil] date.value from a date without a type
+      def self.untyped_date_value(event_dates)
+        event_dates.flatten.compact.find do |date|
+          next if date.type.present?
+
+          return date_value(date)
+        end
+      end
+      private_class_method :untyped_date_value
+
+      # @param [Cocina::Models::DescriptiveValue] a date object from an event
+      # @return [String, nil] value from date object
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def self.date_value(date)
+        return date.value if date&.value.present?
+
+        Array(date&.structuredValue).find do |structured_value|
+          return structured_value.value if structured_value&.value.present?
+        end
+
+        Array(date&.parallelValue).find do |parallel_value|
+          return parallel_value.value if parallel_value&.value.present?
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      private_class_method :date_value
+    end
+  end
+end

data/lib/dor_indexing/builders/event_place_builder.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Builders
+    # Finds the place to index from publication events
+    class EventPlaceBuilder
+      # @param [Cocina::Models::Event] event
+      # @return [String] the place value for Solr
+      def self.build(event)
+        new(event).build
+      end
+
+      def initialize(event)
+        @event = event
+      end
+
+      def build
+        return unless event
+
+        primary_location || location_from(flat_locations)
+      end
+
+      private
+
+      attr_reader :event
+
+      def primary_location
+        location_from([flat_locations.find { |location| location.status == 'primary' }].compact)
+      end
+
+      def location_from(locations)
+        return if locations.empty?
+
+        value_locations_for(locations) ||
+          marccountry_text_for(locations) ||
+          marccountry_code_for(locations)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def flat_locations
+        @flat_locations ||= begin
+          locations = if event.parallelEvent.present?
+                        event.parallelEvent.flat_map { |parallel_event| Array(parallel_event.location) }
+                      else
+                        Array(event.location)
+                      end
+          locations.flat_map { |location| location.parallelValue.presence || location.structuredValue.presence || location }
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def marccountry_text_for(locations)
+        locations.find { |location| marc_country?(location) && location.value }&.value
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def marccountry_code_for(locations)
+        DorIndexing::MarcCountry.from_code(locations.find { |location| marc_country?(location) && location.code }&.code) ||
+          DorIndexing::MarcCountry.from_uri(locations.find { |location| location.uri&.start_with?(DorIndexing::MarcCountry::MARC_COUNTRY_URI) }&.uri)
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def value_locations_for(locations)
+        locations.select { |location| location.value && !marc_country?(location) }.map(&:value).join(' : ').presence
+      end
+
+      def marc_country?(location)
+        location.source&.code == DorIndexing::MarcCountry::MARC_COUNTRY_CODE ||
+          location.source&.uri == DorIndexing::MarcCountry::MARC_COUNTRY_URI
+      end
+    end
+  end
+end

data/lib/dor_indexing/builders/geographic_builder.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Builders
+    # Builds the geographic fields for a solr document
+    class GeographicBuilder
+      # @param [Array<Cocina::Models::Subject>] subjects
+      # @return [Array<String>] the geographic values for Solr
+      def self.build(subjects)
+        new(subjects).build
+      end
+
+      def initialize(subjects)
+        @subjects = Array(subjects)
+      end
+
+      def build
+        extract_place_from_subjects(subjects)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def extract_place_from_subjects(local_subjects)
+        (
+          build_place_nodes(local_subjects.select { |node| node.type == 'place' }) +
+          local_subjects.reject(&:type).flat_map do |subject|
+            next extract_place_from_subjects(subject.parallelValue) if subject.parallelValue.present?
+
+            build_place_nodes(Array(subject.structuredValue).select { |node| node.type == 'place' })
+          end
+        ).uniq
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      attr_reader :subjects
+
+      def build_place_nodes(nodes)
+        Array(nodes).flat_map { |node| build_place(node) }
+      end
+
+      # @param [Cocina::Models::DescriptiveValue]
+      def build_place(node)
+        remove_trailing_punctuation(
+          Array(node.value) +
+          place_from_code(node) +
+          build_hierarchical_subject(node) +
+          Array(node.parallelValue).flat_map { |child| build_place(child) }
+        )
+      end
+
+      # @return [Array<String>]
+      # rubocop:disable Metrics/MethodLength
+      def place_from_code(node)
+        return [] unless node.code && node.source
+
+        code = node.code.gsub(/[^\w-]/, '') # remove any punctuation (except dash).
+        case node.source.code
+        when 'marcgac'
+          [Marc::Vocab::GeographicArea.fetch(code)]
+        when 'marccountry'
+          [Marc::Vocab::Country.fetch(code)]
+        else
+          []
+        end
+      rescue KeyError
+        # Per Arcadia, halt HB notification until after data clean-up.
+        # Honeybadger.notify("[DATA ERROR] Unable to find \"#{code}\" in authority \"#{node.source.code}\"")
+        []
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def build_hierarchical_subject(node)
+        Array(node.structuredValue&.map(&:value).presence&.join(' '))
+      end
+
+      def remove_trailing_punctuation(strings)
+        strings.map { |str| str.sub(%r{[ ,\\/;]+$}, '') }
+      end
+    end
+  end
+end

data/lib/dor_indexing/builders/name_builder.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Builders
+    # Builds the author fields for a solr document
+    class NameBuilder
+      # @param [Symbol] strategy ":first" is the strategy for how to choose a name if primary and display name is not found
+      # @return [Array<String>] names
+      def self.build_all(cocina_contributors)
+        flat_names = cocina_contributors.filter_map { |cocina_contributor| flat_names_for(cocina_contributor) }.flatten
+        flat_names.filter_map { |name| build_name(name) }
+      end
+
+      # @param [Symbol] strategy ":first" is the strategy for how to choose a name if primary and display name is not found
+      # @return [String] name
+      def self.build_primary_name(names, strategy: :first)
+        names = Array(names) unless names.is_a?(Array)
+        flat_names = flat_names_for(names)
+        name = display_name_for(flat_names) || primary_name_for(flat_names)
+        name ||= flat_names.first if strategy == :first
+        return build_name(name) if name
+
+        flat_names.filter_map { |one| build_name(one) }.first
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
+      def self.build_name(name)
+        if name.groupedValue.present?
+          name.groupedValue.find { |grouped_value| grouped_value.type == 'name' }&.value
+        elsif name.structuredValue.present?
+          name_part = joined_name_parts(name, 'name', '. ').presence
+          surname = joined_name_parts(name, 'surname', ' ')
+          forename = joined_name_parts(name, 'forename', ' ')
+          terms_of_address = joined_name_parts(name, 'term of address', ', ')
+          life_dates = joined_name_parts(name, 'life dates', ', ')
+          activity_dates = joined_name_parts(name, 'activity dates', ', ')
+          joined_name = name_part || join_parts([surname, forename], ', ')
+          joined_name = join_parts([joined_name, terms_of_address], ' ')
+          joined_name = join_parts([joined_name, life_dates], ', ')
+          join_parts([joined_name, activity_dates], ', ')
+        else
+          name.value
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+
+      def self.display_name_for(names)
+        names.find { |name| name.type == 'display' }
+      end
+
+      def self.primary_name_for(names)
+        names.find { |name| name.status == 'primary' }
+      end
+
+      def self.flat_names_for(names)
+        names.flat_map { |name| name.parallelValue.presence || name }
+      end
+
+      def self.joined_name_parts(name, type, joiner)
+        join_parts(name.structuredValue.select { |structured_value| structured_value.type == type }.map(&:value), joiner)
+      end
+
+      def self.join_parts(parts, joiner)
+        parts.compact_blank.join(joiner)
+      end
+    end
+  end
+end

data/lib/dor_indexing/builders/orcid_builder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Builders
+    # Helper methods for working with Orcid in Cocina
+    class OrcidBuilder
+      # NOTE: there is similar code in orcid_client which fetches
+      # ORCIDs out of cocina.  Consider consolidating at some point or keeping in sync.
+      # see https://github.com/sul-dlss/orcid_client/blob/main/lib/sul_orcid_client/cocina_support.rb
+      # and https://github.com/sul-dlss/dor_indexing_app/issues/1022
+
+      # @param [Array<Cocina::Models::Contributor>] contributors
+      # @return [String] the list of contributor ORCIDs to index into solr
+      def self.build(contributors)
+        new(contributors).build
+      end
+
+      def initialize(contributors)
+        @contributors = Array(contributors)
+      end
+
+      def build
+        cited_contributors.filter_map { |contributor| orcidid(contributor) }
+      end
+
+      private
+
+      attr_reader :contributors
+
+      # @param [Cocina::Models::Contributor] array of contributors
+      # @return [Array<String>] array of contributors who are listed as cited
+      # Note that non-cited contributors are excluded.
+      def cited_contributors
+        contributors.select { |contributor| cited?(contributor) }
+      end
+
+      # @param [Cocina::Models::Contributor] contributor to check
+      # @return [Boolean] true unless the contributor has a citation status of false
+      def cited?(contributor)
+        contributor.note.none? { |note| note.type == 'citation status' && note.value == 'false' }
+      end
+
+      # @param [Cocina::Models::Contributor] contributor to check
+      # @return [String, nil] orcid id including host if present
+      # rubocop:disable Metrics/AbcSize
+      def orcidid(contributor)
+        identifier = contributor.identifier.find { |id| id.type == 'ORCID' }
+        return unless identifier
+
+        # some records have the full ORCID URI in the data, just return it if so, e.g. druid:gf852zt8324
+        return identifier.uri if identifier.uri
+        return identifier.value if identifier.value.start_with?('https://orcid.org/')
+
+        # some records have just the ORCIDID without the URL prefix, add it if so, e.g. druid:tp865ng1792
+        return URI.join('https://orcid.org/', identifier.value).to_s if identifier.source.uri.blank?
+
+        URI.join(identifier.source.uri, identifier.value).to_s
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/dor_indexing/builders/publisher_name_builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Builders
+    # Builds the publisher name for a solr document
+    class PublisherNameBuilder
+      def self.build(events)
+        roles = publisher_roles(events)
+
+        publisher_names_for(roles)
+      end
+
+      def self.publisher_roles(events)
+        contributors = events.flat_map(&:contributor).compact
+        return [] if contributors.blank?
+
+        contributors.select { |contributor| Array(contributor.role).any? { |role| role.value&.downcase == 'publisher' } }
+      end
+
+      # Returns the primary publisher if available.
+      def self.publisher_names_for(publisher_roles)
+        return if publisher_roles.blank?
+
+        primary_publisher = publisher_roles.find { |role| role.status == 'primary' }
+
+        return contributor_name(primary_publisher).first if primary_publisher
+
+        publisher_roles.flat_map { |contributor| contributor_name(contributor) }.join(' : ')
+      end
+
+      def self.contributor_name(contributor)
+        contributor.name.flat_map { |name| flat_name(name) }
+      end
+
+      def self.flat_name(value)
+        primary_name = value.parallelValue&.find { |role| role.status == 'primary' }
+        return parallel_name(value.parallelValue) if !primary_name && value.parallelValue.present?
+
+        return name_for(primary_name) if primary_name
+
+        name_for(value)
+      end
+
+      def self.name_for(name)
+        name.structuredValue.present? ? name.structuredValue.map(&:value).join('. ') : name.value
+      end
+
+      def self.parallel_name(names)
+        names.map { |single_name| name_for(single_name) }.join(' : ')
+      end
+    end
+  end
+end

data/lib/dor_indexing/builders/temporal_builder.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Builders
+    # Builds the temporal fields for a solr document
+    class TemporalBuilder
+      # @param [Array<Cocina::Models::Subject>] subjects
+      # @return [Array<String>] the temporal values for Solr
+      def self.build(subjects)
+        new(subjects).build
+      end
+
+      def initialize(subjects)
+        @subjects = Array(subjects)
+      end
+
+      def build
+        extract_temporal_from_subjects(subjects)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def extract_temporal_from_subjects(local_subjects)
+        (
+          build_temporal_nodes(local_subjects.select { |node| node.type == 'time' }) +
+          local_subjects.reject(&:type).flat_map do |subject|
+            next extract_temporal_from_subjects(subject.parallelValue) if subject.parallelValue.present?
+
+            build_temporal_nodes(Array(subject.structuredValue).select { |node| node.type == 'time' })
+          end
+        ).uniq
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      attr_reader :subjects
+
+      def build_temporal_nodes(nodes)
+        Array(nodes).flat_map { |node| build_temporal(node) }
+      end
+
+      # @param [Cocina::Models::DescriptiveValue]
+      def build_temporal(node)
+        remove_trailing_punctuation(
+          Array(node.value) +
+          Array(node.structuredValue).map(&:value) +
+          Array(node.parallelValue).flat_map { |child| build_temporal(child) }
+        )
+      end
+
+      def remove_trailing_punctuation(strings)
+        strings.map { |str| str.sub(%r{[ ,\\/;]+$}, '') }
+      end
+    end
+  end
+end