dor_indexing 1.0.0

data/lib/dor_indexing/marc_country.rb

@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  # Helper for MARC country codes
+  # rubocop:disable Metrics/ClassLength
+  class MarcCountry
+    MARC_COUNTRY_URI = 'http://id.loc.gov/vocabulary/countries/'
+
+    MARC_COUNTRY_CODE = 'marccountry'
+
+    COUNTRY_CODES = { # rubocop:disable Metrics/CollectionLiteralLength
+      'aa' => 'Albania',
+      'abc' => 'Alberta',
+      'aca' => 'Australian Capital Territory',
+      'ae' => 'Algeria',
+      'af' => 'Afghanistan',
+      'ag' => 'Argentina',
+      'ai' => 'Armenia (Republic)',
+      'aj' => 'Azerbaijan',
+      'aku' => 'Alaska',
+      'alu' => 'Alabama',
+      'am' => 'Anguilla',
+      'an' => 'Andorra',
+      'ao' => 'Angola',
+      'aq' => 'Antigua and Barbuda',
+      'aru' => 'Arkansas',
+      'as' => 'American Samoa',
+      'at' => 'Australia',
+      'au' => 'Austria',
+      'aw' => 'Aruba',
+      'ay' => 'Antarctica',
+      'azu' => 'Arizona',
+      'ba' => 'Bahrain',
+      'bb' => 'Barbados',
+      'bcc' => 'British Columbia',
+      'bd' => 'Burundi',
+      'be' => 'Belgium',
+      'bf' => 'Bahamas',
+      'bg' => 'Bangladesh',
+      'bh' => 'Belize',
+      'bi' => 'British Indian Ocean Territory',
+      'bl' => 'Brazil',
+      'bm' => 'Bermuda Islands',
+      'bn' => 'Bosnia and Herzegovina',
+      'bo' => 'Bolivia',
+      'bp' => 'Solomon Islands',
+      'br' => 'Burma',
+      'bs' => 'Botswana',
+      'bt' => 'Bhutan',
+      'bu' => 'Bulgaria',
+      'bv' => 'Bouvet Island',
+      'bw' => 'Belarus',
+      'bx' => 'Brunei',
+      'ca' => 'Caribbean Netherlands',
+      'cau' => 'California',
+      'cb' => 'Cambodia',
+      'cc' => 'China',
+      'cd' => 'Chad',
+      'ce' => 'Sri Lanka',
+      'cf' => 'Congo (Brazzaville)',
+      'cg' => 'Congo (Democratic Republic)',
+      'ch' => 'China (Republic : 1949- )',
+      'ci' => 'Croatia',
+      'cj' => 'Cayman Islands',
+      'ck' => 'Colombia',
+      'cl' => 'Chile',
+      'cm' => 'Cameroon',
+      'co' => 'Curaçao',
+      'cou' => 'Colorado',
+      'cq' => 'Comoros',
+      'cr' => 'Costa Rica',
+      'ctu' => 'Connecticut',
+      'cu' => 'Cuba',
+      'cv' => 'Cabo Verde',
+      'cw' => 'Cook Islands',
+      'cx' => 'Central African Republic',
+      'cy' => 'Cyprus',
+      'dcu' => 'District of Columbia',
+      'deu' => 'Delaware',
+      'dk' => 'Denmark',
+      'dm' => 'Benin',
+      'dq' => 'Dominica',
+      'dr' => 'Dominican Republic',
+      'ea' => 'Eritrea',
+      'ec' => 'Ecuador',
+      'eg' => 'Equatorial Guinea',
+      'em' => 'Timor-Leste',
+      'enk' => 'England',
+      'er' => 'Estonia',
+      'es' => 'El Salvador',
+      'et' => 'Ethiopia',
+      'fa' => 'Faroe Islands',
+      'fg' => 'French Guiana',
+      'fi' => 'Finland',
+      'fj' => 'Fiji',
+      'fk' => 'Falkland Islands',
+      'flu' => 'Florida',
+      'fm' => 'Micronesia (Federated States)',
+      'fp' => 'French Polynesia',
+      'fr' => 'France',
+      'fs' => 'Terres australes et antarctiques françaises',
+      'ft' => 'Djibouti',
+      'gau' => 'Georgia',
+      'gb' => 'Kiribati',
+      'gd' => 'Grenada',
+      'gg' => 'Guernsey',
+      'gh' => 'Ghana',
+      'gi' => 'Gibraltar',
+      'gl' => 'Greenland',
+      'gm' => 'Gambia',
+      'go' => 'Gabon',
+      'gp' => 'Guadeloupe',
+      'gr' => 'Greece',
+      'gs' => 'Georgia (Republic)',
+      'gt' => 'Guatemala',
+      'gu' => 'Guam',
+      'gv' => 'Guinea',
+      'gw' => 'Germany',
+      'gy' => 'Guyana',
+      'gz' => 'Gaza Strip',
+      'hiu' => 'Hawaii',
+      'hm' => 'Heard and McDonald Islands',
+      'ho' => 'Honduras',
+      'ht' => 'Haiti',
+      'hu' => 'Hungary',
+      'iau' => 'Iowa',
+      'ic' => 'Iceland',
+      'idu' => 'Idaho',
+      'ie' => 'Ireland',
+      'ii' => 'India',
+      'ilu' => 'Illinois',
+      'im' => 'Isle of Man',
+      'inu' => 'Indiana',
+      'io' => 'Indonesia',
+      'iq' => 'Iraq',
+      'ir' => 'Iran',
+      'is' => 'Israel',
+      'it' => 'Italy',
+      'iv' => "Côte d'Ivoire",
+      'iy' => 'Iraq-Saudi Arabia Neutral Zone',
+      'ja' => 'Japan',
+      'je' => 'Jersey',
+      'ji' => 'Johnston Atoll',
+      'jm' => 'Jamaica',
+      'jo' => 'Jordan',
+      'ke' => 'Kenya',
+      'kg' => 'Kyrgyzstan',
+      'kn' => 'Korea (North)',
+      'ko' => 'Korea (South)',
+      'ksu' => 'Kansas',
+      'ku' => 'Kuwait',
+      'kv' => 'Kosovo',
+      'kyu' => 'Kentucky',
+      'kz' => 'Kazakhstan',
+      'lau' => 'Louisiana',
+      'lb' => 'Liberia',
+      'le' => 'Lebanon',
+      'lh' => 'Liechtenstein',
+      'li' => 'Lithuania',
+      'lo' => 'Lesotho',
+      'ls' => 'Laos',
+      'lu' => 'Luxembourg',
+      'lv' => 'Latvia',
+      'ly' => 'Libya',
+      'mau' => 'Massachusetts',
+      'mbc' => 'Manitoba',
+      'mc' => 'Monaco',
+      'mdu' => 'Maryland',
+      'meu' => 'Maine',
+      'mf' => 'Mauritius',
+      'mg' => 'Madagascar',
+      'miu' => 'Michigan',
+      'mj' => 'Montserrat',
+      'mk' => 'Oman',
+      'ml' => 'Mali',
+      'mm' => 'Malta',
+      'mnu' => 'Minnesota',
+      'mo' => 'Montenegro',
+      'mou' => 'Missouri',
+      'mp' => 'Mongolia',
+      'mq' => 'Martinique',
+      'mr' => 'Morocco',
+      'msu' => 'Mississippi',
+      'mtu' => 'Montana',
+      'mu' => 'Mauritania',
+      'mv' => 'Moldova',
+      'mw' => 'Malawi',
+      'mx' => 'Mexico',
+      'my' => 'Malaysia',
+      'mz' => 'Mozambique',
+      'nbu' => 'Nebraska',
+      'ncu' => 'North Carolina',
+      'ndu' => 'North Dakota',
+      'ne' => 'Netherlands',
+      'nfc' => 'Newfoundland and Labrador',
+      'ng' => 'Niger',
+      'nhu' => 'New Hampshire',
+      'nik' => 'Northern Ireland',
+      'nju' => 'New Jersey',
+      'nkc' => 'New Brunswick',
+      'nl' => 'New Caledonia',
+      'nmu' => 'New Mexico',
+      'nn' => 'Vanuatu',
+      'no' => 'Norway',
+      'np' => 'Nepal',
+      'nq' => 'Nicaragua',
+      'nr' => 'Nigeria',
+      'nsc' => 'Nova Scotia',
+      'ntc' => 'Northwest Territories',
+      'nu' => 'Nauru',
+      'nuc' => 'Nunavut',
+      'nvu' => 'Nevada',
+      'nw' => 'Northern Mariana Islands',
+      'nx' => 'Norfolk Island',
+      'nyu' => 'New York (State)',
+      'nz' => 'New Zealand',
+      'ohu' => 'Ohio',
+      'oku' => 'Oklahoma',
+      'onc' => 'Ontario',
+      'oru' => 'Oregon',
+      'ot' => 'Mayotte',
+      'pau' => 'Pennsylvania',
+      'pc' => 'Pitcairn Island',
+      'pe' => 'Peru',
+      'pf' => 'Paracel Islands]',
+      'pg' => 'Guinea-Bissau',
+      'ph' => 'Philippines',
+      'pic' => 'Prince Edward Island',
+      'pk' => 'Pakistan',
+      'pl' => 'Poland',
+      'pn' => 'Panama',
+      'po' => 'Portugal',
+      'pp' => 'Papua New Guinea',
+      'pr' => 'Puerto Rico',
+      'pw' => 'Palau',
+      'py' => 'Paraguay',
+      'qa' => 'Qatar',
+      'qea' => 'Queensland',
+      'quc' => 'Québec (Province)',
+      'rb' => 'Serbia',
+      're' => 'Réunion',
+      'rh' => 'Zimbabwe',
+      'riu' => 'Rhode Island',
+      'rm' => 'Romania',
+      'ru' => 'Russia (Federation)',
+      'rw' => 'Rwanda',
+      'sa' => 'South Africa',
+      'sc' => 'Saint-Barthélemy',
+      'scu' => 'South Carolina',
+      'sd' => 'South Sudan',
+      'sdu' => 'South Dakota',
+      'se' => 'Seychelles',
+      'sf' => 'Sao Tome and Principe',
+      'sg' => 'Senegal',
+      'sh' => 'Spanish North Africa',
+      'si' => 'Singapore',
+      'sj' => 'Sudan',
+      'sl' => 'Sierra Leone',
+      'sm' => 'San Marino',
+      'sn' => 'Sint Maarten',
+      'snc' => 'Saskatchewan',
+      'so' => 'Somalia',
+      'sp' => 'Spain',
+      'sq' => 'Eswatini',
+      'sr' => 'Surinam',
+      'ss' => 'Western Sahara',
+      'st' => 'Saint-Martin',
+      'stk' => 'Scotland',
+      'su' => 'Saudi Arabia',
+      'sw' => 'Sweden',
+      'sx' => 'Namibia',
+      'sy' => 'Syria',
+      'sz' => 'Switzerland',
+      'ta' => 'Tajikistan',
+      'tc' => 'Turks and Caicos Islands',
+      'tg' => 'Togo',
+      'th' => 'Thailand',
+      'ti' => 'Tunisia',
+      'tk' => 'Turkmenistan',
+      'tl' => 'Tokelau',
+      'tma' => 'Tasmania',
+      'tnu' => 'Tennessee',
+      'to' => 'Tonga',
+      'tr' => 'Trinidad and Tobago',
+      'ts' => 'United Arab Emirates',
+      'tu' => 'Turkey',
+      'tv' => 'Tuvalu',
+      'txu' => 'Texas',
+      'tz' => 'Tanzania',
+      'ua' => 'Egypt',
+      'uc' => 'United States Misc. Caribbean Islands',
+      'ug' => 'Uganda',
+      'un' => 'Ukraine',
+      'up' => 'United States Misc. Pacific Islands',
+      'utu' => 'Utah',
+      'uv' => 'Burkina Faso',
+      'uy' => 'Uruguay',
+      'uz' => 'Uzbekistan',
+      'vau' => 'Virginia',
+      'vb' => 'British Virgin Islands',
+      'vc' => 'Vatican City',
+      've' => 'Venezuela',
+      'vi' => 'Virgin Islands of the United States',
+      'vm' => 'Vietnam',
+      'vp' => 'Various places',
+      'vra' => 'Victoria',
+      'vtu' => 'Vermont',
+      'wau' => 'Washington (State)',
+      'wea' => 'Western Australia',
+      'wf' => 'Wallis and Futuna',
+      'wiu' => 'Wisconsin',
+      'wj' => 'West Bank of the Jordan River',
+      'wk' => 'Wake Island',
+      'wlk' => 'Wales',
+      'ws' => 'Samoa',
+      'wvu' => 'West Virginia',
+      'wyu' => 'Wyoming',
+      'xa' => 'Christmas Island (Indian Ocean)',
+      'xb' => 'Cocos (Keeling) Islands',
+      'xc' => 'Maldives',
+      'xd' => 'Saint Kitts-Nevis',
+      'xe' => 'Marshall Islands',
+      'xf' => 'Midway Islands',
+      'xga' => 'Coral Sea Islands Territory',
+      'xh' => 'Niue',
+      'xj' => 'Saint Helena',
+      'xk' => 'Saint Lucia',
+      'xl' => 'Saint Pierre and Miquelon',
+      'xm' => 'Saint Vincent and the Grenadines',
+      'xn' => 'North Macedonia',
+      'xna' => 'New South Wales',
+      'xo' => 'Slovakia',
+      'xoa' => 'Northern Territory',
+      'xp' => 'Spratly Island',
+      'xr' => 'Czech Republic',
+      'xra' => 'South Australia',
+      'xs' => 'South Georgia and the South Sandwich Islands',
+      'xv' => 'Slovenia',
+      'xx' => '"No place, unknown, or undetermined"',
+      'xxc' => 'Canada',
+      'xxk' => 'United Kingdom',
+      'xxu' => 'United States',
+      'ye' => 'Yemen',
+      'ykc' => 'Yukon Territory',
+      'za' => 'Zambia'
+    }.freeze
+
+    def self.from_code(code)
+      COUNTRY_CODES[code]
+    end
+
+    def self.from_uri(uri)
+      return unless uri&.start_with?('http://id.loc.gov/vocabulary/countries/')
+
+      COUNTRY_CODES[uri[MARC_COUNTRY_URI.length..]]
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/dor_indexing/selectors/event_selector.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Selectors
+    # Selects the best event to use for indexing
+    class EventSelector
+      # @param [Array<Cocina::Models::Event>] events
+      # @param [String] desired_date_type a string to match the date.type in a Cocina::Models::Event
+      # @return [Cocina::Models::Event, nil] event best matching selected
+      def self.select(events, desired_date_type)
+        date_type_matches_and_primary(events, desired_date_type) ||
+          date_and_event_type_match(events, desired_date_type) ||
+          event_type_matches_but_no_date_type(events, desired_date_type) ||
+          event_has_date_type(events, desired_date_type)
+      end
+
+      # @param [Cocina::Models::DescriptiveValue] a date object from an event
+      # @return [Boolean] true if date.status == primary
+      def self.date_status_primary(date)
+        structured_primary = Array(date.structuredValue).find do |structured_date|
+          structured_date.status == 'primary'
+        end
+
+        parallel_value_primary = Array(date.parallelValue).find do |parallel_value|
+          parallel_value.status == 'primary'
+        end
+
+        date.status == 'primary' || structured_primary || parallel_value_primary
+      end
+
+      # @return [Cocina::Models::Event, nil] event with date of type desired_date_type and of status primary
+      def self.date_type_matches_and_primary(events, desired_date_type)
+        events.find do |event|
+          event_dates = Array(event.date) + Array(event.parallelEvent&.map(&:date))
+          event_dates.flatten.compact.find do |date|
+            next if desired_date_type != date_type(date)
+
+            date_status_primary(date)
+          end
+        end
+      end
+      private_class_method :date_type_matches_and_primary
+
+      # @return [Cocina::Models::Event, nil] event with date of type desired_date_type and the event has matching type
+      def self.date_and_event_type_match(events, desired_date_type)
+        events.find do |event|
+          next unless event_type_matches(event, desired_date_type)
+
+          event_dates = Array(event.date) + Array(event.parallelEvent&.map(&:date))
+          event_dates.flatten.compact.find do |date|
+            desired_date_type == date_type(date)
+          end
+        end
+      end
+      private_class_method :date_and_event_type_match
+
+      # @return [Cocina::Models::Event, nil] event with type of desired_date_type and a date field without a type
+      def self.event_type_matches_but_no_date_type(events, desired_date_type)
+        events.find do |event|
+          next unless event_type_matches(event, desired_date_type)
+
+          event_dates = Array(event.date) + Array(event.parallelEvent&.map(&:date))
+          event_dates.flatten.compact.find do |date|
+            date_type(date).nil?
+          end
+        end
+      end
+      private_class_method :event_type_matches_but_no_date_type
+
+      # @return [Cocina::Models::Event, nil] event with date of type desired_date_type
+      def self.event_has_date_type(events, desired_date_type)
+        events.find do |event|
+          event_dates = Array(event.date) + Array(event.parallelEvent&.map(&:date))
+          event_dates.flatten.compact.find do |date|
+            desired_date_type == date_type(date)
+          end
+        end
+      end
+      private_class_method :event_has_date_type
+
+      # @return [Boolean] true if event type matches or parallelEvent type matches the param
+      def self.event_type_matches(event, desired_type)
+        return true if event.type == desired_type
+
+        matching_event = event.parallelEvent&.find { |parallel_event| parallel_event.type == desired_type }
+        matching_event.present?
+      end
+      private_class_method :event_type_matches
+
+      # @param [Cocina::Models::DescriptiveValue] a date object from an event
+      # @return [String, nil] type from date object
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/AbcSize
+      def self.date_type(date)
+        return date.type if date&.type.present?
+
+        Array(date.structuredValue).find do |structured_value|
+          return structured_value.type if structured_value&.type.present?
+        end
+
+        Array(date.parallelValue).find do |parallel_value|
+          return parallel_value.type if parallel_value&.type.present?
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/AbcSize
+      private_class_method :date_type
+    end
+  end
+end

data/lib/dor_indexing/selectors/pub_year_selector.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  module Selectors
+    # Finds the pub date to index from events
+    class PubYearSelector
+      # @param [Array<Cocina::Models::Events>] events
+      # @return [String] the year value for Solr
+      def self.build(events)
+        new(events).build
+      end
+
+      def initialize(events)
+        @events = events
+      end
+
+      def build
+        date = find_date
+        ParseDate.earliest_year(date).to_s if date.present?
+      end
+
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def find_date
+        primary_date(events) ||
+          EventDateBuilder.build(production_event, 'production') ||
+          EventDateBuilder.build(publication_event, 'publication') ||
+          EventDateBuilder.build(capture_event, 'capture') ||
+          EventDateBuilder.build(copyright_event, 'copyright') ||
+          creation_date ||
+          first_date ||
+          structured_dates(events) ||
+          find_date_in_parallel_events
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      private
+
+      attr_reader :events
+
+      def find_date_in_parallel_events
+        parallel_events = events.flat_map(&:parallelEvent).compact
+        primary_date(parallel_events) ||
+          structured_dates(parallel_events)
+      end
+
+      def primary_date(eligible_events)
+        dates = eligible_events.flat_map(&:date).compact
+        return if dates.blank?
+
+        dates.find { |date| date.status == 'primary' }&.value
+      end
+
+      def first_date
+        dates = events.flat_map(&:date).compact
+        return if dates.blank?
+
+        date_value(dates.first)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def date_value(date)
+        return date.value if date.value
+        return if date.parallelValue.blank?
+
+        primary = date.parallelValue.find { |val| val.status == 'primary' }
+        return primary.value if primary
+
+        structured_values = date.parallelValue.first.structuredValue
+        return find_within_structured_values(structured_values) if structured_values.present?
+
+        date.parallelValue.first.value
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def structured_dates(eligible_events)
+        dates = eligible_events.flat_map(&:date).compact
+        return if dates.blank?
+
+        structured_values = dates.first.structuredValue
+        return if structured_values.blank?
+
+        find_within_structured_values(structured_values)
+      end
+
+      def find_within_structured_values(structured_values)
+        primary = structured_values.find { |date| date.status == 'primary' }
+        return primary.value if primary
+
+        structured_values.first.value
+      end
+
+      def creation_date
+        @creation_date ||= DorIndexing::Builders::EventDateBuilder.build(creation_event, 'creation')
+      end
+
+      def publication_event
+        @publication_event ||= DorIndexing::Selectors::EventSelector.select(events, 'publication')
+      end
+
+      def creation_event
+        @creation_event ||= DorIndexing::Selectors::EventSelector.select(events, 'creation')
+      end
+
+      def capture_event
+        @capture_event ||= DorIndexing::Selectors::EventSelector.select(events, 'capture')
+      end
+
+      def copyright_event
+        @copyright_event ||= DorIndexing::Selectors::EventSelector.select(events, 'copyright')
+      end
+
+      def production_event
+        @production_event ||= DorIndexing::Selectors::EventSelector.select(events, 'production')
+      end
+    end
+  end
+end

data/lib/dor_indexing/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  VERSION = '1.0.0'
+end

data/lib/dor_indexing/workflow_fields.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class DorIndexing
+  # Model for workflow fields
+  class WorkflowFields
+    def self.for(druid:, version:, workflow_client:)
+      new(druid:, version:, workflow_client:).result
+    end
+
+    attr_reader :druid, :version, :workflow_client
+
+    def initialize(druid:, version:, workflow_client:)
+      @druid = druid
+      @version = version
+      @workflow_client = workflow_client
+    end
+
+    # @return [Hash] the partial solr document for processable concerns
+    def result
+      {}.tap do |solr_doc|
+        add_sortable_milestones(solr_doc)
+        add_status(solr_doc)
+      end
+    end
+
+    private
+
+    def status_service
+      @status_service ||= workflow_client.status(druid:, version:)
+    end
+
+    def add_status(solr_doc)
+      # This is the status on the Argo show page (e.g. "v4 In accessioning (described, published, deposited)")
+      solr_doc['status_ssi'] = status_service.display
+      return unless status_service.info[:status_code]
+
+      # This is used for Argo's "Processing Status" facet
+      solr_doc['processing_status_text_ssi'] = status_service.display_simplified
+    end
+
+    def sortable_milestones
+      status_service.milestones.each_with_object({}) do |milestone, sortable|
+        sortable[milestone[:milestone]] ||= []
+        sortable[milestone[:milestone]] << milestone[:at].utc.xmlschema
+      end
+    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)
+        # TODO: we really only need accessioned_earliest and registered_earliest
+        solr_doc["#{milestone}_earliest_dttsi"] = dates.first
+        solr_doc["#{milestone}_latest_dttsi"] = dates.last
+      end
+    end
+  end
+end