bolognese 1.3.1 → 2.3.9

data/lib/bolognese/readers/citeproc_reader.rb

@@ -38,7 +38,7 @@ module Bolognese
         citeproc_type = meta.fetch("type", nil)
         schema_org = CP_TO_SO_TRANSLATIONS[citeproc_type] || "CreativeWork"
         types = {
-          "resourceTypeGeneral" => Bolognese::Utils::SO_TO_DC_TRANSLATIONS[schema_org],
+          "resourceTypeGeneral" => Bolognese::Utils::CP_TO_DC_TRANSLATIONS[citeproc_type],
           "reourceType" => meta.fetch("additionalType", nil),
           "schemaOrg" => schema_org,
           "citeproc" => citeproc_type,
@@ -52,27 +52,29 @@ module Bolognese
           [{ "nameType" => "Organizational", "name" => ":(unav)" }]
         end
         contributors = get_authors(from_citeproc(Array.wrap(meta.fetch("editor", nil))))
-        dates = if meta.fetch("issued", nil).present?
-          [{ "date" => get_date_from_date_parts(meta.fetch("issued", nil)),
-             "dateType" => "Issued" }]
-        else
-          nil
+        translators = get_authors(from_citeproc(Array.wrap(meta.fetch("translator", nil))))
+        translators.each do |translator|
+          translator["contributorType"] = "Translator"
         end
+        contributors += translators
+
+        dates = if date = get_date_from_date_parts(meta.fetch("issued", nil))
+                  if Date.edtf(date).present?
+                    [{ "date" => date,
+                      "dateType" => "Issued" }]
+                  end
+                end
         publication_year = get_date_from_date_parts(meta.fetch("issued", nil)).to_s[0..3]
         rights_list = if meta.fetch("copyright", nil)
-          [{ "rightsUri" => normalize_url(meta.fetch("copyright")) }.compact]
-        else
-          nil
-        end
+                        [hsh_to_spdx("rightsURI" => meta.fetch("copyright"))]
+                      end
         related_identifiers = if meta.fetch("container-title", nil).present? && meta.fetch("ISSN", nil).present?
-          [{ "type" => "Periodical",
-             "relationType" => "IsPartOf",
-             "relatedIdentifierType" => "ISSN",
-             "title" => meta.fetch("container-title", nil),
-             "relatedIdentifier" => meta.fetch("ISSN", nil) }.compact]
-        else
-          nil
-        end
+                                [{ "type" => "Periodical",
+                                  "relationType" => "IsPartOf",
+                                  "relatedIdentifierType" => "ISSN",
+                                  "title" => meta.fetch("container-title", nil),
+                                  "relatedIdentifier" => meta.fetch("ISSN", nil) }.compact]
+                              end
         container = if meta.fetch("container-title", nil).present?
           first_page = meta.fetch("page", nil).present? ? meta.fetch("page").split("-").map(&:strip)[0] : nil
           last_page = meta.fetch("page", nil).present? ? meta.fetch("page").split("-").map(&:strip)[1] : nil
@@ -90,28 +92,18 @@ module Bolognese
           nil
         end
 
-        identifiers = [normalize_id(meta.fetch("id", nil)), normalize_doi(meta.fetch("DOI", nil))].compact.map do |r|
-          r = normalize_id(r)
+        id = normalize_id(meta.fetch("id", nil) || meta.fetch("DOI", nil))
 
-          if r.start_with?("https://doi.org")
-            { "identifierType" => "DOI", "identifier" => r }
-          else
-              { "identifierType" => "URL", "identifier" => r }
-          end
-        end.uniq
-
-        id = Array.wrap(identifiers).first.to_h.fetch("identifier", nil)
-        doi = Array.wrap(identifiers).find { |r| r["identifierType"] == "DOI" }.to_h.fetch("identifier", nil)
-          
         state = id.present? || read_options.present? ? "findable" : "not_found"
-        subjects = Array.wrap(meta.fetch("categories", nil)).map do |s|
-          { "subject" => s }
+        subjects = Array.wrap(meta.fetch("categories", nil)).reduce([]) do |sum, subject|
+          sum += name_to_fos(subject)
+
+          sum
         end
 
         { "id" => id,
-          "identifiers" => identifiers,
           "types" => types,
-          "doi" => doi_from_url(doi),
+          "doi" => doi_from_url(id),
           "url" => normalize_id(meta.fetch("URL", nil)),
           "titles" => [{ "title" => meta.fetch("title", nil) }],
           "creators" => creators,
@@ -121,7 +113,7 @@ module Bolognese
           "related_identifiers" => related_identifiers,
           "dates" => dates,
           "publication_year" => publication_year,
-          "descriptions" => meta.fetch("abstract", nil).present? ? [{ "description" => sanitize(meta.fetch("abstract")), "descriptionType" => "Abstract" }] : [],
+          "descriptions" => meta.fetch("abstract", nil).present? ? [{ "description" => sanitize(meta.fetch("abstract"), new_line: true), "descriptionType" => "Abstract" }] : [],
           "rights_list" => rights_list,
           "version_info" => meta.fetch("version", nil),
           "subjects" => subjects,

data/lib/bolognese/readers/codemeta_reader.rb

@@ -22,19 +22,16 @@ module Bolognese
 
         meta = string.present? ? Maremma.from_json(string) : {}
 
-        identifiers = ([meta.fetch("@id", nil)] + Array.wrap(meta.fetch("identifier", nil))).map do |r|
+        identifiers = Array.wrap(meta.fetch("identifier", nil)).map do |r|
           r = normalize_id(r) if r.is_a?(String)
-          if r.is_a?(String) && r.start_with?("https://doi.org")
-            { "identifierType" => "DOI", "identifier" => r }
-          elsif r.is_a?(String)
+          if r.is_a?(String) && !r.start_with?("https://doi.org")
               { "identifierType" => "URL", "identifier" => r }
           elsif r.is_a?(Hash)
             { "identifierType" => get_identifier_type(r["propertyID"]), "identifier" => r["value"] }
           end
         end.compact.uniq
 
-        id = Array.wrap(identifiers).first.to_h.fetch("identifier", nil)
-        doi = Array.wrap(identifiers).find { |r| r["identifierType"] == "DOI" }.to_h.fetch("identifier", nil)
+        id = normalize_id(options[:doi] || meta.fetch("@id", nil) || meta.fetch("identifier", nil))
 
         has_agents = meta.fetch("agents", nil)
         authors =  has_agents.nil? ? meta.fetch("authors", nil) : has_agents
@@ -46,7 +43,7 @@ module Bolognese
         dates << { "date" => meta.fetch("dateCreated"), "dateType" => "Created" } if meta.fetch("dateCreated", nil).present?
         dates << { "date" => meta.fetch("dateModified"), "dateType" => "Updated" } if meta.fetch("dateModified", nil).present?
         publication_year = meta.fetch("datePublished")[0..3] if meta.fetch("datePublished", nil).present?
-        publisher = meta.fetch("publisher", nil)
+        publisher = { "name" => meta.fetch("publisher", nil) } if meta.fetch("publisher", nil).present?
         state = meta.present? || read_options.present? ? "findable" : "not_found"
         schema_org = meta.fetch("@type", nil)
         types = {
@@ -57,18 +54,20 @@ module Bolognese
           "bibtex" => Bolognese::Utils::SO_TO_BIB_TRANSLATIONS[schema_org] || "misc",
           "ris" => Bolognese::Utils::SO_TO_RIS_TRANSLATIONS[schema_org] || "GEN"
         }.compact
-        subjects = Array.wrap(meta.fetch("tags", nil)).map do |s|
-          { "subject" => s }
+        subjects = Array.wrap(meta.fetch("tags", nil)).reduce([]) do |sum, subject|
+          sum += name_to_fos(subject)
+
+          sum
         end
 
         has_title = meta.fetch("title", nil)
-
         titles =  has_title.nil? ?  [{ "title" => meta.fetch("name", nil) }] : [{ "title" => has_title }]  
+        rights_list = meta.fetch("licenseId", nil).present? ? [hsh_to_spdx("rightsIdentifier" => meta.fetch("licenseId"))] : nil
 
         { "id" => id,
           "types" => types,
           "identifiers" => identifiers,
-          "doi" => doi_from_url(doi),
+          "doi" => doi_from_url(id),
           "url" => normalize_id(meta.fetch("codeRepository", nil)),
           "titles" => titles,
           "creators" => creators,
@@ -77,8 +76,8 @@ module Bolognese
           #{}"is_part_of" => is_part_of,
           "dates" => dates,
           "publication_year" => publication_year,
-          "descriptions" => meta.fetch("description", nil).present? ? [{ "description" => sanitize(meta.fetch("description")), "descriptionType" => "Abstract" }] : nil,
-          "rights_list" => [{ "rightsUri" => meta.fetch("license", nil) }.compact],
+          "descriptions" => meta.fetch("description", nil).present? ? [{ "description" => sanitize(meta.fetch("description"), new_line: true), "descriptionType" => "Abstract" }] : nil,
+          "rights_list" => rights_list,
           "version_info" => meta.fetch("version", nil),
           "subjects" => subjects,
           "state" => state

data/lib/bolognese/readers/crosscite_reader.rb

@@ -7,7 +7,10 @@ module Bolognese
         errors = jsonlint(string)
         return { "errors" => errors } if errors.present?
 
-        string.present? ? Maremma.from_json(string) : {}
+        crosscite = string.present? ? Maremma.from_json(string) : {}
+        crosscite["publisher"] = normalize_publisher(crosscite["publisher"]) if crosscite.fetch("publisher", nil).present?
+
+        crosscite
       end
     end
   end

data/lib/bolognese/readers/crossref_reader.rb

@@ -4,12 +4,18 @@ module Bolognese
   module Readers
     module CrossrefReader
       # CrossRef types from https://api.crossref.org/types
+
+      CR_TO_DC_CONTRIBUTOR_TYPES = {
+        "editor" => "Editor",
+        "translator" => "Translator",
+      }
+
       def get_crossref(id: nil, **options)
         return { "string" => nil, "state" => "not_found" } unless id.present?
 
         doi = doi_from_url(id)
         url = "https://api.crossref.org/works/#{doi}/transform/application/vnd.crossref.unixsd+xml"
-        response = Maremma.get(url, accept: "text/xml", raw: true)
+        response = Maremma.get(url, accept: "text/xml;charset=utf-8", raw: true)
         string = response.body.fetch("data", nil)
         string = Nokogiri::XML(string, nil, 'UTF-8', &:noblanks).to_s if string.present?
 
@@ -31,7 +37,7 @@ module Bolognese
         end
 
         # model should be one of book, conference, database, dissertation, journal, peer_review, posted_content,
-        # report-paper, sa_component, standard
+        # report_paper, sa_component, standard
         model = meta.dig("crossref").to_h.keys.last
 
         resource_type = nil
@@ -40,26 +46,29 @@ module Bolognese
         journal_metadata = nil
         journal_issue = {}
         journal_metadata = nil
-        publisher = query.dig("crm_item", 0)
+        publisher = query.dig("crm_item", 0).is_a?(String) ? { "name" => query.dig("crm_item", 0) } : nil
 
         case model
         when "book"
           book_metadata = meta.dig("crossref", "book", "book_metadata")
           book_series_metadata = meta.dig("crossref", "book", "book_series_metadata")
           book_set_metadata = meta.dig("crossref", "book", "book_set_metadata")
-          bibliographic_metadata = meta.dig("crossref", "book", "content_item") || book_metadata || book_series_metadata
+          bibliographic_metadata = meta.dig("crossref", "book", "content_item") || book_metadata || book_series_metadata || book_set_metadata
           resource_type = bibliographic_metadata.fetch("component_type", nil) ? "book-" + bibliographic_metadata.fetch("component_type") : "book"
-          publisher = book_metadata.present? ? book_metadata.dig("publisher", "publisher_name") : book_series_metadata.dig("publisher", "publisher_name")
+          # publisher = if book_metadata.present?
+          #               book_metadata.dig("publisher", "publisher_name")
+          #             elsif book_series_metadata.present?
+          #               book_series_metadata.dig("publisher", "publisher_name")
+          #             end
         when "conference"
-          event_metadata = meta.dig("crossref", "conference", "event_metadata") || {}
+          event_metadata = meta.dig("crossref", "conference", "event_metadata") || {}
           bibliographic_metadata = meta.dig("crossref", "conference", "conference_paper").to_h
         when "journal"
-          journal_metadata = meta.dig("crossref", "journal", "journal_metadata") || {}
+          journal_metadata = meta.dig("crossref", "journal", "journal_metadata") || {}
           journal_issue = meta.dig("crossref", "journal", "journal_issue") || {}
           journal_article = meta.dig("crossref", "journal", "journal_article") || {}
           bibliographic_metadata = journal_article.presence || journal_issue.presence || journal_metadata
           program_metadata = bibliographic_metadata.dig("crossmark", "custom_metadata", "program") || bibliographic_metadata.dig("program")
-          
           resource_type = if journal_article.present?
                               "journal_article"
                             elsif journal_issue.present?
@@ -69,7 +78,7 @@ module Bolognese
                             end
         when "posted_content"
           bibliographic_metadata = meta.dig("crossref", "posted_content").to_h
-          publisher = bibliographic_metadata.dig("institution", "institution_name")
+          publisher ||= bibliographic_metadata.dig("institution", "institution_name")
         when "sa_component"
           bibliographic_metadata = meta.dig("crossref", "sa_component", "component_list", "component").to_h
           related_identifier = Array.wrap(query.to_h["crm_item"]).find { |cr| cr["name"] == "relation" }
@@ -77,12 +86,19 @@ module Bolognese
         when "database"
           bibliographic_metadata = meta.dig("crossref", "database", "dataset").to_h
           resource_type = "dataset"
+        when "report_paper"
+          bibliographic_metadata = meta.dig("crossref", "report_paper", "report_paper_metadata").to_h
+          resource_type = "report"
+        when "peer_review"
+          bibliographic_metadata = meta.dig("crossref", "peer_review")
+        when "dissertation"
+          bibliographic_metadata = meta.dig("crossref", "dissertation")
         end
 
         resource_type = (resource_type || model).to_s.underscore.camelcase.presence
         schema_org = Bolognese::Utils::CR_TO_SO_TRANSLATIONS[resource_type] || "ScholarlyArticle"
         types = {
-          "resourceTypeGeneral" => Bolognese::Utils::SO_TO_DC_TRANSLATIONS[schema_org],
+          "resourceTypeGeneral" => Bolognese::Utils::CR_TO_DC_TRANSLATIONS[resource_type],
           "resourceType" => resource_type,
           "schemaOrg" => schema_org,
           "citeproc" => Bolognese::Utils::CR_TO_CP_TRANSLATIONS[resource_type] || "article-journal",
@@ -103,59 +119,85 @@ module Bolognese
                      end
                    end.compact
                  else
-                   [{ "title" => ":{unav)" }]
+                   [{ "title" => ":(unav)" }]
                  end
 
-        date_created = Array.wrap(query.to_h["crm_item"]).find { |cr| cr["name"] == "created" }
+        date_published = crossref_date_published(bibliographic_metadata)
+        if date_published.present?
+          date_published = { "date" => date_published, "dateType" => "Issued" }
+        else
+          date_published = Array.wrap(query.to_h["crm_item"]).find { |cr| cr["name"] == "created" }
+          date_published = { "date" => date_published.fetch("__content__", "")[0..9], "dateType" => "Issued" } if date_published.present?
+        end
         date_updated = Array.wrap(query.to_h["crm_item"]).find { |cr| cr["name"] == "last-update" }
         date_updated = { "date" => date_updated.fetch("__content__", nil), "dateType" => "Updated" } if date_updated.present?
-        dates = [
-          { "date" => crossref_date_published(bibliographic_metadata) || date_created.to_h.fetch("__content__", "")[0..9].presence, "dateType" => "Issued" }, date_updated
-        ].compact
-        publication_year = crossref_date_published(bibliographic_metadata).present? ? crossref_date_published(bibliographic_metadata)[0..3] : date_created.to_h.fetch("__content__", "")[0..3].presence
+
+        date_registered = Array.wrap(query.to_h["crm_item"]).find { |cr| cr["name"] == "deposit-timestamp" }
+        date_registered = get_datetime_from_time(date_registered.fetch("__content__", nil)) if date_registered.present?
+
+        # check that date is valid iso8601 date
+        date_published = nil unless Date.edtf(date_published.to_h["date"]).present?
+        date_updated = nil unless Date.edtf(date_updated.to_h["date"]).present?
+
+        dates = [date_published, date_updated].compact
+        publication_year = date_published.to_h.fetch("date", "")[0..3].presence
+
         state = meta.present? || read_options.present? ? "findable" : "not_found"
 
-        related_identifiers = Array.wrap(crossref_is_part_of(journal_metadata)) + Array.wrap(crossref_references(bibliographic_metadata))
-        container = if journal_metadata.present? || book_metadata.present?
-          issn = normalize_issn(journal_metadata.to_h.fetch("issn", nil))
-
-          { "type" => "Journal",
-            "identifier" => issn,
-            "identifierType" => issn.present? ? "ISSN" : nil,
-            "title" => journal_metadata.to_h["full_title"],
-            "volume" => journal_issue.dig("journal_volume", "volume"),
-            "issue" => journal_issue.dig("issue"),
-            "firstPage" => bibliographic_metadata.dig("pages", "first_page"),
-            "lastPage" => bibliographic_metadata.dig("pages", "last_page") }.compact
-        elsif book_series_metadata.to_h.fetch("series_metadata", nil).present?
-          issn = normalize_issn(book_series_metadata.dig("series_metadata", "issn"))
-
-          { "type" => "Book Series",
-            "identifier" => issn,
-            "identifierType" => issn.present? ? "ISSN" : nil,
-            "title" => book_series_metadata.dig("series_metadata", "titles", "title"),
-            "volume" => bibliographic_metadata.fetch("volume", nil) }.compact
-        else
-          nil
-        end
+        related_identifiers = Array.wrap(crossref_is_part_of(journal_metadata)) + Array.wrap(crossref_references(bibliographic_metadata)) + Array.wrap(crossref_has_translation(program_metadata)) + Array.wrap(crossref_is_translation_of(program_metadata))
+
+        container = if journal_metadata.present?
+                      issn = normalize_issn(journal_metadata.to_h.fetch("issn", nil))
+
+                      { "type" => "Journal",
+                        "identifier" => issn,
+                        "identifierType" => issn.present? ? "ISSN" : nil,
+                        "title" => parse_attributes(journal_metadata.to_h["full_title"]),
+                        "volume" => parse_attributes(journal_issue.dig("journal_volume", "volume")),
+                        "issue" => parse_attributes(journal_issue.dig("issue")),
+                        "firstPage" => bibliographic_metadata.dig("pages", "first_page") || parse_attributes(journal_article.to_h.dig("publisher_item", "item_number"), first: true),
+                        "lastPage" => bibliographic_metadata.dig("pages", "last_page") }.compact
+
+                    # By using book_metadata, we can account for where resource_type is `BookChapter` and not assume its a whole book
+                    elsif book_metadata.present?
+                      identifiers = crossref_alternate_identifiers(book_metadata)
+
+                      {
+                        "type" => "Book",
+                        "title" => book_metadata.dig("titles", "title"),
+                        "firstPage" => bibliographic_metadata.dig("pages", "first_page"),
+                        "lastPage" => bibliographic_metadata.dig("pages", "last_page"),
+                        "identifiers" => identifiers,
+                      }.compact
 
-        identifiers = [{ "identifierType" => "DOI", "identifier" => normalize_doi(options[:doi] || options[:id] || bibliographic_metadata.dig("doi_data", "doi")) }, crossref_alternate_identifiers(bibliographic_metadata)].compact
+                    elsif book_series_metadata.to_h.fetch("series_metadata", nil).present?
+                      issn = normalize_issn(book_series_metadata.dig("series_metadata", "issn"))
 
-        id = Array.wrap(identifiers).first.to_h.fetch("identifier", nil)
-        doi = Array.wrap(identifiers).find { |r| r["identifierType"] == "DOI" }.to_h.fetch("identifier", nil)
+                      { "type" => "Book Series",
+                        "identifier" => issn,
+                        "identifierType" => issn.present? ? "ISSN" : nil,
+                        "title" => book_series_metadata.dig("series_metadata", "titles", "title"),
+                        "volume" => bibliographic_metadata.fetch("volume", nil) }.compact
+                    end
+
+        id = normalize_doi(options[:doi] || options[:id] || bibliographic_metadata.dig("doi_data", "doi"))
+
+        # Let sections override this in case of alternative metadata structures, such as book chapters, which
+        # have their meta inside `content_item`, but the main book indentifers inside of `book_metadata`
+        identifiers ||= crossref_alternate_identifiers(bibliographic_metadata)
 
         { "id" => id,
           "types" => types,
-          "doi" => doi_from_url(doi),
+          "doi" => doi_from_url(id),
           "url" => parse_attributes(bibliographic_metadata.dig("doi_data", "resource"), first: true),
           "titles" => titles,
           "identifiers" => identifiers,
           "creators" => crossref_people(bibliographic_metadata, "author"),
-          "contributors" => crossref_people(bibliographic_metadata, "editor"),
+          "contributors" => crossref_people(bibliographic_metadata, "editor") + crossref_people(bibliographic_metadata, "translator"),
           "funding_references" => crossref_funding_reference(program_metadata),
           "publisher" => publisher,
           "container" => container,
-          "agency" => agency = options[:ra] || "Crossref",
+          "agency" => agency = options[:ra] || "crossref",
           "related_identifiers" => related_identifiers,
           "dates" => dates,
           "publication_year" => publication_year,
@@ -166,30 +208,40 @@ module Bolognese
           "language" => nil,
           "sizes" => nil,
           "schema_version" => nil,
-          "state" => state
+          "state" => state,
+          "date_registered" => date_registered
         }.merge(read_options)
       end
 
       def crossref_alternate_identifiers(bibliographic_metadata)
         if bibliographic_metadata.dig("publisher_item", "item_number").present?
-          { "identifier" => parse_attributes(bibliographic_metadata.dig("publisher_item", "item_number")),
-            "identifierType" => "Publisher ID" }
+          Array.wrap(bibliographic_metadata.dig("publisher_item", "item_number")).map do |item|
+            if item.is_a?(String)
+              { "identifier" => item,
+                "identifierType" => "Publisher ID" }
+            else
+              { "identifier" => item.fetch("__content__", nil),
+                "identifierType" => item.fetch("item_number_type", nil) || "Publisher ID" }
+            end
+          end
         elsif parse_attributes(bibliographic_metadata.fetch("item_number", nil)).present?
-          { "identifier" => parse_attributes(bibliographic_metadata.fetch("item_number", nil)),
-            "identifierType" => "Publisher ID" }
+          [{ "identifier" => parse_attributes(bibliographic_metadata.fetch("item_number", nil)),
+            "identifierType" => "Publisher ID" }]
         elsif parse_attributes(bibliographic_metadata.fetch("isbn", nil)).present?
-          { "identifier" => parse_attributes(bibliographic_metadata.fetch("isbn", nil), first: true),
-            "identifierType" => "ISBN" }
+          [{ "identifier" => parse_attributes(bibliographic_metadata.fetch("isbn", nil), first: true),
+             "identifierType" => "ISBN" }]
+        else
+          []
         end
       end
 
       def crossref_description(bibliographic_metadata)
         abstract = Array.wrap(bibliographic_metadata.dig("abstract")).map do |r|
-          { "descriptionType" => "Abstract", "description" => sanitize(parse_attributes(r, content: 'p')) }.compact
+          { "descriptionType" => "Abstract", "description" => sanitize(parse_attributes(r, content: 'p'), new_line: true) }.compact
         end
 
         description = Array.wrap(bibliographic_metadata.dig("description")).map do |r|
-          { "descriptionType" => "Other", "description" => sanitize(parse_attributes(r)) }.compact
+          { "descriptionType" => "Other", "description" => sanitize(parse_attributes(r), new_line: true) }.compact
         end
 
         (abstract + description)
@@ -199,32 +251,50 @@ 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|
-            { "rightsUri" => normalize_url(parse_attributes(license)) }
+            hsh_to_spdx("rightsURI" => parse_attributes(license))
           end.uniq
         else
-          nil
+          []
         end
       end
 
       def crossref_people(bibliographic_metadata, contributor_role)
-        person = bibliographic_metadata.dig("contributors", "person_name")
-        person = [{ "name" => ":(unav)", "contributor_role"=>"author" }] if contributor_role == "author" && Array.wrap(person).select { |a| a["contributor_role"] == "author" }.blank?
+        person = bibliographic_metadata.dig("contributors", "person_name") || bibliographic_metadata.dig("person_name")
+        organization = Array.wrap(bibliographic_metadata.dig("contributors", "organization"))
+        person = [{ "name" => ":(unav)", "contributor_role"=>"author" }] if contributor_role == "author" && Array.wrap(person).select { |a| a["contributor_role"] == "author" }.blank? && Array.wrap(organization).select { |a| a["contributor_role"] == "author" }.blank?
 
-        Array.wrap(person).select { |a| a["contributor_role"] == contributor_role }.map do |a|
+        (Array.wrap(person) + Array.wrap(organization)).select { |a| a["contributor_role"] == contributor_role }.map do |a|
           name_identifiers = normalize_orcid(parse_attributes(a["ORCID"])).present? ? [{ "nameIdentifier" => normalize_orcid(parse_attributes(a["ORCID"])), "nameIdentifierScheme" => "ORCID", "schemeUri"=>"https://orcid.org" }] : nil
           if a["surname"].present? || a["given_name"].present? || name_identifiers.present?
+            given_name = parse_attributes(a["given_name"])
+            family_name = parse_attributes(a["surname"])
+            affiliation = Array.wrap(a["affiliation"]).map do |a|
+              if a.is_a?(Hash) && a.key?("__content__") && a["__content__"].strip.blank?
+                nil
+              elsif a.is_a?(Hash) && a.key?("__content__")
+                { "name" => a["__content__"] }
+              elsif a.is_a?(Hash)
+                a
+              elsif a.strip.blank?
+                nil
+              elsif a.is_a?(String)
+               { "name" => a }
+              end
+            end.compact
+
             { "nameType" => "Personal",
               "nameIdentifiers" => name_identifiers,
-              "name" => [a["surname"], a["given_name"]].join(", "),
-              "givenName" => a["given_name"],
-              "familyName" => a["surname"],
-              "affiliation" => Array.wrap(a["affiliation"]).map { |a| { "name" => a }}.presence,
-              "contributorType" => contributor_role == "editor" ? "Editor" : nil }.compact
+              "name" => [family_name, given_name].compact.join(", "),
+              "givenName" => given_name,
+              "familyName" => family_name,
+              "affiliation" => affiliation.presence,
+              "contributorType" => contributor_role == 'author' ? nil : CR_TO_DC_CONTRIBUTOR_TYPES[a["contributor_role"]] }.compact
           else
             { "nameType" => "Organizational",
-              "name" => a["name"] }
+              "name" => a["name"] || a["__content__"],
+              "contributorType" => contributor_role == 'author' ? nil : CR_TO_DC_CONTRIBUTOR_TYPES[a["contributor_role"]] }.compact
           end
-        end.unwrap
+        end
       end
 
       def crossref_funding_reference(program_metadata)
@@ -236,7 +306,7 @@ module Bolognese
           award_title = nil
           award_number = nil
           award_uri = nil
-          
+
           Array.wrap(f.fetch("assertion")).each do |a|
             if a.fetch("name") == "award_number"
               award_number = a.fetch("__content__", nil)
@@ -299,6 +369,32 @@ module Bolognese
           end
         end.compact.unwrap
       end
+    
+      def crossref_has_translation(program_metadata)
+        refs = program_metadata.dig("related_item") if program_metadata.is_a?(Hash)
+        Array.wrap(refs).select { |a| a.dig("intra_work_relation", "relationship_type") == "hasTranslation" }.map do |c|
+          if c.dig("intra_work_relation", "identifier_type") == "doi"
+            { "relatedIdentifier" => parse_attributes(c["intra_work_relation"]).downcase,
+              "relationType" => "HasTranslation",
+              "relatedIdentifierType" => "DOI" }.compact
+          else
+            nil
+          end
+        end.compact.unwrap
+      end
+
+      def crossref_is_translation_of(program_metadata)
+        refs = program_metadata.dig("related_item") if program_metadata.is_a?(Hash)
+        Array.wrap(refs).select { |a| a.dig("intra_work_relation", "relationship_type") == "isTranslationOf" }.map do |c|
+          if c.dig("intra_work_relation", "identifier_type") == "doi"
+            { "relatedIdentifier" => parse_attributes(c["intra_work_relation"]).downcase,
+              "relationType" => "IsTranslationOf",
+              "relatedIdentifierType" => "DOI" }.compact
+          else
+            nil
+          end
+        end.compact.unwrap
+      end
     end
   end
 end

data/lib/bolognese/readers/datacite_json_reader.rb

@@ -7,7 +7,10 @@ module Bolognese
         errors = jsonlint(string)
         return { "errors" => errors } if errors.present?
 
-        string.present? ? Maremma.from_json(string).transform_keys! { |key| key.underscore } : {}
+        datacite_json = string.present? ? Maremma.from_json(string).transform_keys! { |key| key.underscore } : {}
+        datacite_json["publisher"] = normalize_publisher(datacite_json["publisher"]) if datacite_json.fetch("publisher", nil).present?
+
+        datacite_json
       end
     end
   end