Index person_id (#1050)

* Index person_id

* Add related_doi indexing (#1051)

* Add related_doi indexing

* Add relation_type to the hash

* Add more fields to the related_dois indexed info

* Add tests for related_dois

* Add related_dois to elasticsearch

* Appease Rubocop

app/models/doi.rb

@@ -244,6 +244,7 @@ class Doi < ApplicationRecord
       indexes :provider_id,                    type: :keyword
       indexes :consortium_id,                  type: :keyword
       indexes :resource_type_id,               type: :keyword
+      indexes :person_id,                      type: :keyword
       indexes :affiliation_id,                 type: :keyword
       indexes :fair_affiliation_id,            type: :keyword
       indexes :organization_id,                type: :keyword
@@ -549,6 +550,14 @@ class Doi < ApplicationRecord
       indexes :fields_of_science, type: :keyword
       indexes :fields_of_science_combined, type: :keyword
       indexes :fields_of_science_repository, type: :keyword
+      indexes :related_doi, type: :object, properties: {
+        client_id: { type: :keyword },
+        doi: { type: :keyword },
+        organization_id: { type: :keyword },
+        person_id: { type: :keyword },
+        resource_type_id: { type: :keyword },
+        resource_type_id_and_name: { type: :keyword },
+      }
     end
   end
 
@@ -1619,6 +1628,10 @@ def consortium_id
     client.provider.consortium_id.downcase if client.present? && client.provider.consortium_id.present?
   end
 
+  def related_dois
+    Doi::Indexer::RelatedDoiIndexer.new(related_identifiers).as_indexed_json
+  end
+
   def related_dmp_ids
     Array.wrap(related_identifiers).select { |related_identifier|
       related_identifier["relatedIdentifierType"] == "DOI"

app/models/doi/indexer/related_doi_indexer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Doi::Indexer
+  class RelatedDoiIndexer
+    def initialize(related_identifiers)
+      @related_identifiers = related_identifiers
+      @related_dois = nil
+    end
+
+    def related_dois
+      @related_dois ||= @related_identifiers.select { |r| r["relatedIdentifierType"] == "DOI" }
+    end
+
+    def related_grouped_by_id
+      related_dois.group_by { |r| r["relatedIdentifier"].downcase }
+    end
+
+    def relation_types_gouped_by_id
+      related_grouped_by_id.transform_values do |values|
+        values.map { |val| val["relationType"].underscore }.uniq
+      end
+    end
+
+    def related_doi_ids
+      related_grouped_by_id.keys
+    end
+
+    def dois
+      Doi.where(doi: related_doi_ids)
+    end
+
+    def indexed_dois
+      dois.map { |d| RelatedIdentifierDenormalizer.new(d).to_hash }
+    end
+
+    def as_indexed_json
+      rtypes = relation_types_gouped_by_id
+      indexed_dois.map do |indexed_doi|
+        doi = indexed_doi["doi"]
+        indexed_doi["relation_type"] = rtypes[doi]
+        indexed_doi
+      end
+    end
+  end
+end

app/models/doi/indexer/related_identifier_denormalizer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Doi::Indexer
+  class RelatedIdentifierDenormalizer
+    attr_reader :related_doi
+
+    def initialize(doi)
+      @related_doi = doi
+    end
+
+    def to_hash
+      %w[
+        client_id
+        doi
+        organization_id
+        person_id
+        resource_type_id
+        resource_type_id_and_name
+      ].index_with { |method_name| send(method_name) }
+    end
+
+    delegate :resource_type_id, to: :related_doi
+    delegate :resource_type_id_and_name, to: :related_doi
+    delegate :organization_id, to: :related_doi
+    delegate :person_id, to: :related_doi
+    delegate :client_id, to: :related_doi
+
+    def doi
+      @related_doi.doi.downcase
+    end
+  end
+end

spec/models/doi_verified_related_identifiers_spec.rb

@@ -0,0 +1,60 @@
+
+# frozen_string_literal: true
+
+require "rails_helper"
+
+describe Doi, type: :model, vcr: true, elasticsearch: true do
+  describe "related_doi" do
+    let(:client) { create(:client) }
+    let(:target_doi) do
+      create(:doi,
+        client: client,
+        aasm_state: "findable",
+        types: { "resourceTypeGeneral" => "Dataset" }
+      )
+    end
+    let(:doi) do
+      create(:doi,
+        client: client,
+        aasm_state: "findable",
+        related_identifiers: [
+          {
+            "relatedIdentifier": target_doi.doi,
+            "relatedIdentifierType": "DOI",
+            "relationType": "HasPart",
+            "resourceTypeGeneral": "OutputManagementPlan",
+          },
+          {
+            "relatedIdentifier": target_doi.doi,
+            "relatedIdentifierType": "DOI",
+            "relationType": "Cites",
+            "resourceTypeGeneral": "Text",
+          }
+        ])
+    end
+
+    it "indexes related_dois" do
+      expect(doi.related_dois.first["doi"]).to eq(target_doi.doi.downcase)
+    end
+
+    it "indexes related doi's client_id" do
+      expect(doi.related_dois.first["client_id"]).to eq(target_doi.client_id)
+    end
+
+    it "indexes related doi's person_id" do
+      expect(doi.related_dois.first["person_id"]).to eq(target_doi.person_id)
+    end
+
+    it "does not index related doi's claimed resource_type_id" do
+      expect(doi.related_dois.first["resource_type_id"]).not_to eq("output_management_plan")
+    end
+
+    it "indexes related doi's true resource_type_id" do
+      expect(doi.related_dois.first["resource_type_id"]).to eq("dataset")
+    end
+
+    it "indexes all relations to the related doi" do
+      expect(doi.related_dois.first["relation_type"]).to eq(["has_part", "cites"])
+    end
+  end
+end