bolognese 1.0.6 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba8f7ba69c381c964db85cd05abe07d5a1cbd75eb183a3b620bc374430b7dd5b
-  data.tar.gz: 97d81da9e70f8942c66d577ab47e77f310244c37a7cccffa961bb1aefb46b974
+  metadata.gz: fb41752abec17479d1f11b7b7f0f7a4c5aad50698eae00d55e0e8adc71d2b5ce
+  data.tar.gz: d5b6df042eccfd780f2af437d79a12c26a28d99e6c740a06644f84a651cc458d
 SHA512:
-  metadata.gz: d0ae170b389bc7a005935f3da908c4a1754674462011eff2e425b796641a5c5f675e6dff6d2bf4de4354cb452309fc467bdb8064a626391e050d736ea035d0f4
-  data.tar.gz: 51bb1e44e863de1670cd31ebcdb53cd6193f925d83d8d4a675dece1d0246fe88cb54ae829098e6f9b71af291753a4810d772fb10af0a1269f4c46d61659d4592
+  metadata.gz: 54669b2f390738ea6232ffde8866b4e57d829784b96168f5d0fde43b7672250be828e4c62cab815670cbac7056569e012338539022a78b0ef8979c4a05f8a52b
+  data.tar.gz: fc73f2fd0a8306c71458b0eff727f6b338d65623c5bf58079bb08eb711a02d90e57895599ba2b499a9fbf23f8a22f22e02490f12cf2a2c6af4afadcd8857d018

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bolognese (1.0.6)
+    bolognese (1.0.7)
       activesupport (>= 4.2.5, < 6)
       benchmark_methods (~> 0.7)
       bibtex-ruby (~> 4.1)

data/lib/bolognese/author_utils.rb

@@ -105,7 +105,7 @@ module Bolognese
 
     # parse array of author strings into CSL format
     def get_authors(authors)
-      Array.wrap(authors).map { |author| get_one_author(author) }.unwrap
+      Array.wrap(authors).map { |author| get_one_author(author) }.compact
     end
 
     # parse nameIdentifier from DataCite

data/lib/bolognese/datacite_utils.rb

@@ -58,7 +58,7 @@ module Bolognese
 
       xml.contributors do
         Array.wrap(contributor).each do |con|
-          xml.contributor("contributorType" => con["contributorType"] || "Other") do
+          xml.contributor("contributorType" => con["contributor_type"] || "Other") do
             insert_person(xml, con, "contributor")
           end
         end
@@ -67,8 +67,9 @@ module Bolognese
 
     def insert_person(xml, person, type)
       person_name = person["familyName"].present? ? [person["familyName"], person["givenName"]].compact.join(", ") : person["name"]
+      attributes = person["type"].present? ? { "nameType" => person["type"] + "al" } : {}
 
-      xml.send(type + "Name", person_name)
+      xml.send(type + "Name", person_name, attributes)
       xml.givenName(person["givenName"]) if person["givenName"].present?
       xml.familyName(person["familyName"]) if person["familyName"].present?
       xml.nameIdentifier(person["id"], 'schemeURI' => 'http://orcid.org/', 'nameIdentifierScheme' => 'ORCID') if person["id"].present?
@@ -76,16 +77,16 @@ module Bolognese
 
     def insert_titles(xml)
       xml.titles do
-        Array.wrap(title).each do |tit|
-          if tit.is_a?(Hash)
-            t = tit
+        Array.wrap(titles).each do |title|
+          if title.is_a?(Hash)
+            t = title
           else
             t = {}
-            t["text"] = tit
+            t["title"] = title
           end
 
-          attributes = { 'lang' => t["lang"], 'titleType' => t["title_type"] }.compact
-          xml.title(t["text"], attributes)
+          attributes = { 'titleType' => t["title_type"], 'lang' => t["lang"] }.compact
+          xml.title(t["title"], attributes)
         end
       end
     end
@@ -98,16 +99,11 @@ module Bolognese
       xml.publicationYear(publication_year)
     end
 
-    def res_type
-      { "resource_type_general" => types["resource_type_general"] || Metadata::SO_TO_DC_TRANSLATIONS[types["type"]] || "Other",
-        "__content__" => types["resource_type"] || types["type"] }
-    end
-
     def insert_resource_type(xml)
       return xml unless types["type"].present?
 
-      xml.resourceType(res_type["__content__"],
-        'resourceTypeGeneral' => res_type["resource_type_general"])
+      xml.resourceType(types["resource_type"] || types["type"],
+        'resourceTypeGeneral' => types["resource_type_general"] || Metadata::SO_TO_DC_TRANSLATIONS[types["type"]] || "Other")
     end
 
     def insert_alternate_identifiers(xml)
@@ -115,7 +111,7 @@ module Bolognese
 
       xml.alternateIdentifiers do
         Array.wrap(alternate_identifiers).each do |alternate_identifier|
-          xml.alternateIdentifier(alternate_identifier["name"], 'alternateIdentifierType' => alternate_identifier["type"])
+          xml.alternateIdentifier(alternate_identifier["alternate_identifier"], 'alternateIdentifierType' => alternate_identifier["alternate_identifier_type"])
         end
       end
     end
@@ -125,7 +121,8 @@ module Bolognese
 
       xml.dates do
         Array.wrap(dates).each do |date|
-          xml.date(date["date"], 'dateType' => date["date_type"] || "Issued")
+          attributes = { 'dateType' => date["date_type"] || "Issued", 'dateInformation' => date["date_information"] }.compact
+          xml.date(date["date"], attributes)
         end
       end
     end
@@ -136,36 +133,30 @@ module Bolognese
       xml.fundingReferences do
         Array.wrap(funding_references).each do |funding_reference|
           xml.fundingReference do
-            insert_funding_reference(xml, funding_reference)
+            xml.funderName(funding_reference["funder_name"])
+            xml.funderIdentifier(funding_reference["funder_identifier"], { "funderIdentifierType" => funding_reference["funder_identifier_type"] }.compact) if funding_reference["funder_identifier"].present?
+            xml.awardNumber(funding_reference["award_number"], { "awardURI" => funding_reference["award_uri"] }.compact) if funding_reference["award_number"].present? || funding_reference["award_uri"].present?
+            xml.awardTitle(funding_reference["award_title"]) if funding_reference["award_title"].present?
           end
         end
       end
     end
 
-    def insert_funding_reference(xml, funding_reference)
-      xml.funderName(funding_reference["funder_name"]) if funding_reference["funder_name"].present?
-      xml.funderIdentifier(funding_reference["funder_identifier"], "funderIdentifierType" => "Crossref Funder ID") if funding_reference["funder_identifier"].present?
-    end
-
     def insert_subjects(xml)
-      return xml unless keywords.present?
+      return xml unless subjects.present?
 
       xml.subjects do
-        keywords.each do |subject|
-          if subject.is_a?(String) then
-            # If we've been read from somewhere that it was just a string output that
-            xml.subject(subject)
+        subjects.each do |subject|
+          if subject.is_a?(Hash)
+            s = subject
           else
-            # Otherwise we'll assume a hash and therefore find/add attributes as appropriate
-            subject_node = xml.subject(subject['text'])
-            if subject["subject_scheme"].present? then
-              subject_node['subjectScheme'] = subject["subject_scheme"]
-            end
-
-            if subject["scheme_uri"].present? then
-              subject_node['schemeURI'] = subject["scheme_uri"]
-            end
+            s = {}
+            s["subject"] = subject
           end
+
+          attributes = { "subjectScheme" => s["subject_scheme"], "schemeURI" => s["scheme_uri"], "valueURI" => s["value_uri"], "lang" => s["lang"] }.compact
+
+          xml.subject(s["subject"], attributes)
         end
       end
     end
@@ -185,51 +176,56 @@ module Bolognese
             'relatedIdentifierType' => related_identifier["related_identifier_type"],
             'relationType' => related_identifier["relation_type"],
             'resourceTypeGeneral' => related_identifier["resource_type_general"] }.compact
-          xml.relatedIdentifier(related_identifier["id"], attributes)
+
+          attributes.merge({ 'relatedMetadataScheme' => related_identifier["related_metadata_schema"],
+            'schemeURI' => related_identifier["scheme_uri"],
+            'schemeType' => related_identifier["scheme_type"]}.compact) if %w(HasMetadata IsMetadataFor).include?(related_identifier["relation_type"])
+
+          xml.relatedIdentifier(related_identifier["related_identifier"], attributes)
         end
       end
     end
 
     def insert_rights_list(xml)
-      return xml unless rights.present?
+      return xml unless rights_list.present?
 
       xml.rightsList do
-        Array.wrap(rights).each do |lic|
-          if lic.is_a?(Hash)
-            l = lic
+        Array.wrap(rights_list).each do |rights|
+          if rights.is_a?(Hash)
+            r = rights
           else
-            l = {}
-            l["name"] = lic
-            l["id"] = normalize_id(lic)
+            r = {}
+            r["rights"] = rights
+            r["rights_uri"] = normalize_id(rights)
           end
 
-          attributes = { 'rightsURI' => l["id"] }.compact
+          attributes = { 'rightsURI' => r["rights_uri"], 'lang' => r["lang"] }.compact
 
-          xml.rights(l["name"], attributes)
+          xml.rights(r["rights"], attributes)
         end
       end
     end
 
     def insert_descriptions(xml)
-      return xml unless description.present? || periodical && periodical["title"].present?
+      return xml unless descriptions.present? || periodical && periodical["title"].present?
 
       xml.descriptions do
         if periodical && periodical["title"].present?
           xml.description(periodical["title"], 'descriptionType' => "SeriesInformation")
         end
 
-        Array.wrap(description).each do |des|
-          if des.is_a?(Hash)
-            d = des
+        Array.wrap(descriptions).each do |description|
+          if description.is_a?(Hash)
+            d = description
           else
             d = {}
-            d["text"] = des
-            d["type"] = "Abstract"
+            d["description"] = description
+            d["description_type"] = "Abstract"
           end
 
-          attributes = { 'lang' => d["lang"], 'descriptionType' => d["type"] || "Abstract" }.compact
+          attributes = { 'lang' => d["lang"], 'descriptionType' => d["description_type"] || "Abstract" }.compact
 
-          xml.description(d["text"], attributes)
+          xml.description(d["description"], attributes)
         end
       end
     end

data/lib/bolognese/metadata.rb

@@ -6,11 +6,11 @@ module Bolognese
   class Metadata
     include Bolognese::MetadataUtils
 
-    attr_writer :id, :provider_id, :client_id, :doi, :identifier, :creator, :contributor, :title, :publisher, 
-                :rights, :dates, :publication_year, :volume, :first_page, :last_page, :url, :version,
-                :keywords, :contributor, :description, :alternate_identifiers, :language, :size,
+    attr_writer :id, :provider_id, :client_id, :doi, :identifier, :creator, :contributor, :titles, :publisher, 
+                :rights_list, :dates, :publication_year, :volume, :first_page, :last_page, :url, :version,
+                :subjects, :contributor, :descriptions, :alternate_identifiers, :language, :sizes,
                 :formats, :schema_version, :meta, :periodical,
-                :format, :funding_references, :state, :geo_location,
+                :format, :funding_references, :state, :geo_locations,
                 :types, :content_url, :related_identifiers
 
     def initialize(input: nil, from: nil, **options)
@@ -104,24 +104,24 @@ module Bolognese
       meta.fetch("errors", nil) || datacite_errors(xml: datacite, schema_version: schema_version)
     end
     
-    def description
-      @description ||= meta.fetch("description", nil)
+    def descriptions
+      @descriptions ||= meta.fetch("descriptions", nil)
     end
 
-    def rights
-      @rights ||= meta.fetch("rights", nil)
+    def rights_list
+      @rights_list ||= meta.fetch("rights_list", nil)
     end
 
-    def keywords
-      @keywords ||= meta.fetch("keywords", nil)
+    def subjects
+      @subjects ||= meta.fetch("subjects", nil)
     end
 
     def language
       @language ||= meta.fetch("language", nil)
     end
 
-    def size
-      @size ||= meta.fetch("size", nil)
+    def sizes
+      @sizes ||= meta.fetch("sizes", nil)
     end
 
     def formats
@@ -156,8 +156,8 @@ module Bolognese
       @periodical ||= meta.fetch("periodical", nil)
     end
 
-    def geo_location
-      @geo_location ||= meta.fetch("geo_location", nil)
+    def geo_locations
+      @geo_locations ||= meta.fetch("geo_locations", nil)
     end
 
     def dates
@@ -188,8 +188,8 @@ module Bolognese
       @types ||= meta.fetch("types", nil)
     end
 
-    def title
-      @title ||= meta.fetch("title", nil)
+    def titles
+      @titles ||= meta.fetch("titles", nil)
     end
 
     def creator

data/lib/bolognese/metadata_utils.rb

@@ -103,12 +103,12 @@ module Bolognese
 
     def reverse
       { "citation" => Array.wrap(related_identifiers).select { |ri| ri["relation_type"] == "IsReferencedBy" }.map do |r| 
-        { "@id" => normalize_doi(r["id"]),
+        { "@id" => normalize_doi(r["related_identifier"]),
           "@type" => r["resource_type_general"] || "CreativeWork",
           "identifier" => r["related_identifier_type"] == "DOI" ? nil : to_identifier(r) }.compact
         end.unwrap,
         "isBasedOn" => Array.wrap(related_identifiers).select { |ri| ri["relation_type"] == "IsSupplementTo" }.map do |r| 
-          { "@id" => normalize_doi(r["id"]),
+          { "@id" => normalize_doi(r["related_identifier"]),
             "@type" => r["resource_type_general"] || "CreativeWork",
             "identifier" => r["related_identifier_type"] == "DOI" ? nil : to_identifier(r) }.compact
         end.unwrap }.compact
@@ -122,19 +122,19 @@ module Bolognese
       {
         "type" => types["citeproc"],
         "id" => identifier,
-        "categories" => Array.wrap(keywords).map { |k| parse_attributes(k, content: "text", first: true) }.presence,
+        "categories" => Array.wrap(subjects).map { |k| parse_attributes(k, content: "subject", first: true) }.presence,
         "language" => language,
         "author" => to_citeproc(creator),
         "contributor" => to_citeproc(contributor),
         "issued" => get_date(dates, "Issued") ? get_date_parts(get_date(dates, "Issued")) : nil,
         "submitted" => Array.wrap(dates).find { |d| d["type"] == "Submitted" }.to_h.fetch("__content__", nil),
-        "abstract" => parse_attributes(description, content: "text", first: true),
+        "abstract" => parse_attributes(descriptions, content: "description", first: true),
         "container-title" => periodical && periodical["title"],
         "DOI" => doi,
         "issue" => issue,
         "page" => [first_page, last_page].compact.join("-").presence,
         "publisher" => publisher,
-        "title" => parse_attributes(title, content: "text", first: true),
+        "title" => parse_attributes(titles, content: "title", first: true),
         "URL" => url,
         "version" => version,
         "volume" => volume

data/lib/bolognese/readers/bibtex_reader.rb

@@ -52,7 +52,7 @@ module Bolognese
              "relation_type" => "IsPartOf",
              "related_identifier_type" => "ISSN",
              "title" => meta.journal.to_s,
-             "id" => meta.try(:issn).to_s.presence }.compact]
+             "related_identifier" => meta.try(:issn).to_s.presence }.compact]
         else
           nil
         end
@@ -79,7 +79,7 @@ module Bolognese
           "types" => types,
           "doi" => doi,
           "url" => meta.try(:url).to_s,
-          "title" => [{ "text" => meta.try(:title).to_s }],
+          "titles" => [{ "title" => meta.try(:title).to_s }],
           "creator" => author,
           "periodical" => periodical,
           "publisher" => meta.try(:publisher).to_s.presence,
@@ -89,8 +89,8 @@ module Bolognese
           "volume" => meta.try(:volume).to_s.presence,
           "page_first" => page_first,
           "page_last" => page_last,
-          "description" => [{ "text" => meta.try(:abstract) && sanitize(meta.abstract.to_s).presence }],
-          "rights" => [{ "id" => meta.try(:copyright).to_s.presence }.compact],
+          "descriptions" => [{ "description" => meta.try(:abstract) && sanitize(meta.abstract.to_s).presence }],
+          "rights_list" => [{ "rights_uri" => meta.try(:copyright).to_s.presence }.compact],
           "state" => state
         }
       end

data/lib/bolognese/readers/citeproc_reader.rb

@@ -53,8 +53,8 @@ module Bolognese
           nil
         end
         publication_year = get_date_from_date_parts(meta.fetch("issued", nil)).to_s[0..3]
-        rights = if meta.fetch("copyright", nil)
-          [{ "id" => normalize_url(meta.fetch("copyright")) }.compact]
+        rights_list = if meta.fetch("copyright", nil)
+          [{ "rights_uri" => normalize_url(meta.fetch("copyright")) }.compact]
         else
           nil
         end
@@ -76,12 +76,15 @@ module Bolognese
         end
         id = normalize_id(meta.fetch("id", nil))
         state = id.present? ? "findable" : "not_found"
+        subjects = Array.wrap(meta.fetch("categories")).map do |s|
+          { "subject" => s }
+        end
 
         { "id" => id,
           "types" => types,
           "doi" => doi_from_url(doi),
           "url" => normalize_id(meta.fetch("URL", nil)),
-          "title" => [{ "text" => meta.fetch("title", nil) }],
+          "titles" => [{ "title" => meta.fetch("title", nil) }],
           "creator" => creator,
           "contributor" => contributor,
           "periodical" => periodical,
@@ -91,10 +94,10 @@ module Bolognese
           "publication_year" => publication_year,
           "volume" => meta.fetch("volume", nil),
           #{}"pagination" => meta.pages.to_s.presence,
-          "description" => meta.fetch("abstract", nil).present? ? [{ "text" => sanitize(meta.fetch("abstract")) }] : [],
-          "rights" => rights,
+          "descriptions" => meta.fetch("abstract", nil).present? ? [{ "description" => sanitize(meta.fetch("abstract")) }] : [],
+          "rights_list" => rights_list,
           "version" => meta.fetch("version", nil),
-          "keywords" => meta.fetch("categories", nil),
+          "subjects" => subjects,
           "state" => state
         }
       end

data/lib/bolognese/readers/codemeta_reader.rb

@@ -39,23 +39,26 @@ module Bolognese
           "bibtex" => Bolognese::Utils::SO_TO_BIB_TRANSLATIONS[type] || "misc",
           "ris" => Bolognese::Utils::SO_TO_RIS_TRANSLATIONS[type] || "GEN"
         }.compact
+        subjects = Array.wrap(meta.fetch("tags", nil)).map do |s|
+          { "subject" => s }
+        end
 
         { "id" => id,
           "types" => types,
           "identifier" => identifier,
           "doi" => validate_doi(id),
           "url" => normalize_id(meta.fetch("codeRepository", nil)),
-          "title" => [{ "text" => meta.fetch("title", nil) }],
+          "titles" => [{ "title" => meta.fetch("title", nil) }],
           "creator" => author,
           "contributor" => contributor,
           "publisher" => publisher,
           #{}"is_part_of" => is_part_of,
           "dates" => dates,
           "publication_year" => publication_year,
-          "description" => meta.fetch("description", nil).present? ? [{ "text" => sanitize(meta.fetch("description")) }] : nil,
-          "rights" => [{ "id" => meta.fetch("license", nil) }.compact],
+          "descriptions" => meta.fetch("description", nil).present? ? [{ "description" => sanitize(meta.fetch("description")) }] : nil,
+          "rights_list" => [{ "rights_uri" => meta.fetch("license", nil) }.compact],
           "version" => meta.fetch("version", nil),
-          "keywords" => meta.fetch("tags", nil),
+          "subjects" => subjects,
           "state" => state
         }
       end

data/lib/bolognese/readers/crossref_reader.rb

@@ -106,7 +106,7 @@ module Bolognese
           "types" => types,
           "doi" => doi,
           "url" => bibliographic_metadata.dig("doi_data", "resource"),
-          "title" => [{ "text" => parse_attributes(bibliographic_metadata.dig("titles", "title")) }],
+          "titles" => [{ "title" => parse_attributes(bibliographic_metadata.dig("titles", "title")) }],
           "alternate_identifiers" => crossref_alternate_identifiers(bibliographic_metadata),
           "creator" => crossref_people(bibliographic_metadata, "author"),
           "contributor" => crossref_people(bibliographic_metadata, "editor"),
@@ -121,12 +121,12 @@ module Bolognese
           "issue" => journal_issue.dig("issue"),
           "first_page" => bibliographic_metadata.dig("pages", "first_page"),
           "last_page" => bibliographic_metadata.dig("pages", "last_page"),
-          "description" => crossref_description(bibliographic_metadata),
-          "rights" => crossref_license(program_metadata),
+          "descriptions" => crossref_description(bibliographic_metadata),
+          "rights_list" => crossref_license(program_metadata),
           "version" => nil,
-          "keywords" => nil,
+          "subjects" => nil,
           "language" => nil,
-          "size" => nil,
+          "sizes" => nil,
           "schema_version" => nil,
           "state" => state
         }
@@ -134,19 +134,21 @@ module Bolognese
 
       def crossref_alternate_identifiers(bibliographic_metadata)
         if bibliographic_metadata.fetch("publisher_item", nil).present?
-          parse_attributes(bibliographic_metadata.dig("publisher_item", "item_number"))
+          { "alternate_identifier" => parse_attributes(bibliographic_metadata.dig("publisher_item", "item_number")),
+            "alternate_identifier_type" => "Publisher ID" }
         else
-          parse_attributes(bibliographic_metadata.fetch("item_number", nil))
+          { "alternate_identifier" => parse_attributes(bibliographic_metadata.fetch("item_number", nil)),
+            "alternate_identifier_type" => "Publisher ID" }
         end
       end
 
       def crossref_description(bibliographic_metadata)
         abstract = Array.wrap(bibliographic_metadata.dig("abstract")).map do |r|
-          { "type" => "Abstract", "text" => sanitize(parse_attributes(r, content: 'p')) }.compact
+          { "description_type" => "Abstract", "description" => sanitize(parse_attributes(r, content: 'p')) }.compact
         end
 
         description = Array.wrap(bibliographic_metadata.dig("description")).map do |r|
-          { "type" => "Other", "text" => sanitize(parse_attributes(r)) }.compact
+          { "description_type" => "Other", "description" => sanitize(parse_attributes(r)) }.compact
         end
 
         (abstract + description)
@@ -156,7 +158,7 @@ module Bolognese
         access_indicator = Array.wrap(program_metadata).find { |m| m["name"] == "AccessIndicators" }
         if access_indicator.present?
           Array.wrap(access_indicator["license_ref"]).map do |license|
-            { "id" => normalize_url(parse_attributes(license)) }
+            { "rights_uri" => normalize_url(parse_attributes(license)) }
           end.uniq
         else
           nil
@@ -179,13 +181,17 @@ module Bolognese
         fundref = Array.wrap(program_metadata).find { |a| a["name"] == "fundref" } || {}
         Array.wrap(fundref.fetch("assertion", [])).select { |a| a["name"] == "fundgroup" }.map do |f|
           f = Array.wrap(f.fetch("assertion", nil)).first
-
-          { "funder_identifier" => normalize_id(f.dig("assertion", "__content__")),
-            "funder_name" => f.dig("__content__").strip,
-            "award_title" => f.fetch("awardTitle", nil),
+          funder_identifier = normalize_id(f.dig("assertion", "__content__"))
+          funder_identifier_type = funder_identifier.present? ?  "Crossref Funder ID" : nil
+          award_title = f.fetch("awardTitle", nil).present? ? f.fetch("awardTitle") : nil
+
+          { "funder_identifier" => funder_identifier,
+            "funder_identifier_type" => funder_identifier_type,
+            "funder_name" => f.fetch("__content__", "").strip,
+            "award_title" => award_title,
             "award_number" => f.dig("awardNumber", "__content__"),
             "award_uri" => f.dig("awardNumber", "awardURI") }.compact
-        end.unwrap
+        end
       end
 
       def crossref_date_published(bibliographic_metadata)
@@ -200,7 +206,7 @@ module Bolognese
 
       def crossref_is_part_of(model_metadata)
         if model_metadata.present? && model_metadata.fetch("issn", nil).present?
-          { "id" => parse_attributes(model_metadata.fetch("issn", nil), first: true),
+          { "related_identifier" => parse_attributes(model_metadata.fetch("issn", nil), first: true),
             "relation_type" => "IsPartOf",
             "related_identifier_type" => "ISSN",
             "type" => "Periodical",
@@ -214,7 +220,7 @@ module Bolognese
         refs = bibliographic_metadata.dig("citation_list", "citation")
         Array.wrap(refs).select { |a| a["doi"].present? }.map do |c|
           if c["doi"].present?
-            { "id" => parse_attributes(c["doi"]).downcase,
+            { "related_identifier" => parse_attributes(c["doi"]).downcase,
               "relation_type" => "References",
               "related_identifier_type" => "DOI",
               "title" => c["article_title"] }.compact