bolognese 0.2.2 → 2.7.0

data/lib/bolognese/readers/citeproc_reader.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Readers
+    module CiteprocReader
+      CP_TO_SO_TRANSLATIONS = {
+        "song" => "AudioObject",
+        "post-weblog" => "BlogPosting",
+        "dataset" => "Dataset",
+        "graphic" => "ImageObject",
+        "motion_picture" => "Movie",
+        "article-journal" => "ScholarlyArticle",
+        "broadcast" => "VideoObject",
+        "webpage" => "WebPage"
+      }
+
+      CP_TO_RIS_TRANSLATIONS = {
+        "post-weblog" => "BLOG",
+        "dataset" => "DATA",
+        "graphic" => "FIGURE",
+        "book" => "BOOK",
+        "motion_picture" => "MPCT",
+        "article-journal" => "JOUR",
+        "broadcast" => "MPCT",
+        "webpage" => "ELEC"
+      }
+
+      def read_citeproc(string: nil, **options)
+        if string.present?
+          errors = jsonlint(string)
+          return { "errors" => errors } if errors.present?
+        end
+
+        read_options = ActiveSupport::HashWithIndifferentAccess.new(options.except(:doi, :id, :url, :sandbox, :validate, :ra))
+
+        meta = string.present? ? Maremma.from_json(string) : {}
+
+        citeproc_type = meta.fetch("type", nil)
+        schema_org = CP_TO_SO_TRANSLATIONS[citeproc_type] || "CreativeWork"
+        types = {
+          "resourceTypeGeneral" => Bolognese::Utils::CP_TO_DC_TRANSLATIONS[citeproc_type],
+          "reourceType" => meta.fetch("additionalType", nil),
+          "schemaOrg" => schema_org,
+          "citeproc" => citeproc_type,
+          "bibtex" => Bolognese::Utils::SO_TO_BIB_TRANSLATIONS[schema_org] || "misc",
+          "ris" => CP_TO_RIS_TRANSLATIONS[schema_org] || "GEN"
+        }.compact
+
+        creators = if meta.fetch("author", nil).present?
+          get_authors(from_citeproc(Array.wrap(meta.fetch("author", nil))))
+        else
+          [{ "nameType" => "Organizational", "name" => ":(unav)" }]
+        end
+        contributors = get_authors(from_citeproc(Array.wrap(meta.fetch("editor", 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)
+                        [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]
+                              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
+
+          { "type" => "Periodical",
+            "title" => meta.fetch("container-title", nil),
+            "identifier" => meta.fetch("ISSN", nil),
+            "identifierType" => meta.fetch("ISSN", nil).present? ? "ISSN" : nil,
+            "volume" => meta.fetch("volume", nil),
+            "issue" => meta.fetch("issue", nil),
+            "firstPage" => first_page,
+            "lastPage" => last_page
+           }.compact
+        else
+          nil
+        end
+
+        id = normalize_id(meta.fetch("id", nil) || meta.fetch("DOI", nil))
+
+        state = id.present? || read_options.present? ? "findable" : "not_found"
+        subjects = Array.wrap(meta.fetch("categories", nil)).reduce([]) do |sum, subject|
+          sum += name_to_subject(subject)
+
+          sum
+        end
+
+        { "id" => id,
+          "types" => types,
+          "doi" => doi_from_url(id),
+          "url" => normalize_id(meta.fetch("URL", nil)),
+          "titles" => [{ "title" => meta.fetch("title", nil) }],
+          "creators" => creators,
+          "contributors" => contributors,
+          "container" => container,
+          "publisher" => meta.fetch("publisher", nil),
+          "related_identifiers" => related_identifiers,
+          "dates" => dates,
+          "publication_year" => publication_year,
+          "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,
+          "state" => state
+        }.merge(read_options)
+      end
+    end
+  end
+end

data/lib/bolognese/readers/codemeta_reader.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Readers
+    module CodemetaReader
+      def get_codemeta(id: nil, **options)
+        return { "string" => nil, "state" => "not_found" } unless id.present?
+        id = normalize_id(id)
+        response = Maremma.get(github_as_codemeta_url(id), accept: "json", raw: true)
+        string = response.body.fetch("data", nil)
+
+        { "string" => string }
+      end
+
+      def read_codemeta(string: nil, **options)
+        if string.present?
+          errors = jsonlint(string)
+          return { "errors" => errors } if errors.present?
+        end
+
+        read_options = ActiveSupport::HashWithIndifferentAccess.new(options.except(:doi, :id, :url, :sandbox, :validate, :ra))
+
+        meta = string.present? ? Maremma.from_json(string) : {}
+
+        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" => "URL", "identifier" => r }
+          elsif r.is_a?(Hash)
+            { "identifierType" => get_identifier_type(r["propertyID"]), "identifier" => r["value"] }
+          end
+        end.compact.uniq
+
+        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
+        creators = get_authors(from_schema_org_creators(Array.wrap(authors)))
+
+        contributors = get_authors(from_schema_org_contributors(Array.wrap(meta.fetch("editor", nil))))
+        dates = []
+        dates << { "date" => meta.fetch("datePublished"), "dateType" => "Issued" } if meta.fetch("datePublished", nil).present?
+        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 = { "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 = {
+          "resourceTypeGeneral" => Bolognese::Utils::SO_TO_DC_TRANSLATIONS[schema_org],
+          "resourceType" => meta.fetch("additionalType", nil),
+          "schemaOrg" => schema_org,
+          "citeproc" => Bolognese::Utils::SO_TO_CP_TRANSLATIONS[schema_org] || "article-journal",
+          "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)).reduce([]) do |sum, subject|
+          sum += name_to_subject(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(id),
+          "url" => normalize_id(meta.fetch("codeRepository", nil)),
+          "titles" => titles,
+          "creators" => creators,
+          "contributors" => contributors,
+          "publisher" => publisher,
+          #{}"is_part_of" => is_part_of,
+          "dates" => dates,
+          "publication_year" => publication_year,
+          "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
+        }.merge(read_options)
+      end
+
+      # def related_identifiers(relation_type)
+      #   normalize_ids(ids: metadata.fetch(relation_type, nil), relation_type: relation_type)
+      # end
+      #
+      # def same_as
+      #   related_identifiers("isIdenticalTo")
+      # end
+      #
+      # def is_part_of
+      #   related_identifiers("isPartOf")
+      # end
+      #
+      # def has_part
+      #   related_identifiers("hasPart")
+      # end
+      #
+      # def citation
+      #   related_identifiers("citation")
+      # end
+    end
+  end
+end

data/lib/bolognese/readers/crosscite_reader.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Readers
+    module CrossciteReader
+      def read_crosscite(string: nil, **options)
+        errors = jsonlint(string)
+        return { "errors" => errors } if errors.present?
+
+        crosscite = string.present? ? Maremma.from_json(string) : {}
+        crosscite["publisher"] = normalize_publisher(crosscite["publisher"]) if crosscite.fetch("publisher", nil).present?
+
+        crosscite
+      end
+    end
+  end
+end

data/lib/bolognese/readers/crossref_reader.rb

@@ -0,0 +1,413 @@
+# frozen_string_literal: true
+
+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;charset=utf-8", raw: true)
+        string = response.body.fetch("data", nil)
+        string = Nokogiri::XML(string, nil, 'UTF-8', &:noblanks).to_s if string.present?
+
+        { "string" => string }
+      end
+
+      def read_crossref(string: nil, **options)
+        read_options = ActiveSupport::HashWithIndifferentAccess.new(options.except(:doi, :id, :url, :sandbox, :validate, :ra))
+
+        if string.present?
+          m = Maremma.from_xml(string).dig("crossref_result", "query_result", "body", "query", "doi_record") || {}
+          meta = m.dig("doi_record", "crossref", "error").nil? ? m : {}
+
+          # query contains information from outside metadata schema, e.g. publisher name
+          query = Maremma.from_xml(string).dig("crossref_result", "query_result", "body", "query") || {}
+        else
+          meta = {}
+          query = {}
+        end
+
+        # model should be one of book, conference, database, dissertation, journal, peer_review, posted_content,
+        # report_paper, sa_component, standard
+        model = meta.dig("crossref").to_h.keys.last
+
+        resource_type = nil
+        bibliographic_metadata = {}
+        program_metadata = {}
+        journal_metadata = nil
+        journal_issue = {}
+        journal_metadata = nil
+        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 || book_set_metadata
+          resource_type = bibliographic_metadata.fetch("component_type", nil) ? "book-" + bibliographic_metadata.fetch("component_type") : "book"
+          # 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") || {}
+          bibliographic_metadata = meta.dig("crossref", "conference", "conference_paper").to_h
+        when "journal"
+          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?
+                              "journal_issue"
+                            else
+                              "journal"
+                            end
+        when "posted_content"
+          bibliographic_metadata = meta.dig("crossref", "posted_content").to_h
+          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" }
+          journal_metadata = { "relatedIdentifier" => related_identifier.to_h.fetch("__content", nil) }
+        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::CR_TO_DC_TRANSLATIONS[resource_type],
+          "resourceType" => resource_type,
+          "schemaOrg" => schema_org,
+          "citeproc" => Bolognese::Utils::CR_TO_CP_TRANSLATIONS[resource_type] || "article-journal",
+          "bibtex" => Bolognese::Utils::CR_TO_BIB_TRANSLATIONS[resource_type] || "misc",
+          "ris" => Bolognese::Utils::CR_TO_RIS_TRANSLATIONS[resource_type] || "JOUR"
+        }.compact
+
+        titles = if bibliographic_metadata.dig("titles").present?
+                   Array.wrap(bibliographic_metadata.dig("titles")).map do |r|
+                     if r.blank? || (r["title"].blank? && r["original_language_title"].blank?)
+                       nil
+                     elsif r["title"].is_a?(String)
+                       { "title" => sanitize(r["title"]) }
+                     elsif r["original_language_title"].present?
+                       { "title" => sanitize(r.dig("original_language_title", "__content__")), "lang" => r.dig("original_language_title", "language") }
+                     else
+                       { "title" => sanitize(r.dig("title", "__content__")) }.compact
+                     end
+                   end.compact
+                 else
+                   [{ "title" => ":(unav)" }]
+                 end
+
+        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?
+
+        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)) + Array.wrap(crossref_has_translation(program_metadata)) + Array.wrap(crossref_is_translation_of(program_metadata)) + Array.wrap(crossref_is_related_material(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
+
+                    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
+                    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(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") + crossref_people(bibliographic_metadata, "translator"),
+          "funding_references" => crossref_funding_reference(program_metadata),
+          "publisher" => publisher,
+          "container" => container,
+          "agency" => agency = options[:ra] || "crossref",
+          "related_identifiers" => related_identifiers,
+          "dates" => dates,
+          "publication_year" => publication_year,
+          "descriptions" => crossref_description(bibliographic_metadata),
+          "rights_list" => crossref_license(program_metadata),
+          "version_info" => nil,
+          "subjects" => nil,
+          "language" => nil,
+          "sizes" => nil,
+          "schema_version" => nil,
+          "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?
+          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" }]
+        elsif parse_attributes(bibliographic_metadata.fetch("isbn", nil)).present?
+          [{ "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'), new_line: true) }.compact
+        end
+
+        description = Array.wrap(bibliographic_metadata.dig("description")).map do |r|
+          { "descriptionType" => "Other", "description" => sanitize(parse_attributes(r), new_line: true) }.compact
+        end
+
+        (abstract + description)
+      end
+
+      def crossref_license(program_metadata)
+        access_indicator = Array.wrap(program_metadata).find { |m| m["name"] == "AccessIndicators" }
+        if access_indicator.present?
+          Array.wrap(access_indicator["license_ref"]).map do |license|
+            hsh_to_spdx("rightsURI" => parse_attributes(license))
+          end.uniq
+        else
+          []
+        end
+      end
+
+      def crossref_people(bibliographic_metadata, contributor_role)
+        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) + 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" => [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"] || a["__content__"],
+              "contributorType" => contributor_role == 'author' ? nil : CR_TO_DC_CONTRIBUTOR_TYPES[a["contributor_role"]] }.compact
+          end
+        end
+      end
+
+      def crossref_funding_reference(program_metadata)
+        fundref = Array.wrap(program_metadata).find { |a| a["name"] == "fundref" } || {}
+        Array.wrap(fundref.fetch("assertion", [])).select { |a| a["name"] == "fundgroup" && a["assertion"].present? }.map do |f|
+          funder_identifier = nil
+          funder_identifier_type = nil
+          funder_name = nil
+          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)
+              award_uri = a.fetch("awardURI", nil)
+            elsif a.fetch("name") == "funder_name"
+              funder_name = a.fetch("__content__", nil).to_s.squish.presence
+              funder_identifier = validate_funder_doi(a.dig("assertion", "__content__"))
+              funder_identifier_type = "Crossref Funder ID" if funder_identifier.present?
+            end
+          end
+
+          # funder_name is required in DataCite
+          if funder_name.present?
+            { "funderIdentifier" => funder_identifier,
+              "funderIdentifierType" => funder_identifier_type,
+              "funderName" => funder_name,
+              "awardTitle" => award_title,
+              "awardNumber" => award_number,
+              "awardUri" => award_uri }.compact
+          else
+            nil
+          end
+        end.compact
+      end
+
+      def crossref_date_published(bibliographic_metadata)
+        pub_date = Array.wrap(bibliographic_metadata.fetch("publication_date", nil)).presence ||
+          Array.wrap(bibliographic_metadata.fetch("acceptance_date", nil))
+        if pub_date.present?
+          get_date_from_parts(pub_date.first["year"], pub_date.first["month"], pub_date.first["day"])
+        else
+          nil
+        end
+      end
+
+      def crossref_is_part_of(model_metadata)
+        if model_metadata.present? && model_metadata.fetch("issn", nil).present?
+          { "relatedIdentifier" => normalize_issn(model_metadata.fetch("issn", nil)),
+            "relationType" => "IsPartOf",
+            "relatedIdentifierType" => "ISSN",
+            "resourceTypeGeneral" => "Collection" }.compact
+        elsif model_metadata.present? && model_metadata.fetch("relatedIdentifier", nil).present?
+          { "relatedIdentifier" => model_metadata.fetch("relatedIdentifier", nil),
+            "relationType" => "IsPartOf",
+            "relatedIdentifierType" => "DOI" }.compact
+        else
+          nil
+        end
+      end
+
+      def crossref_references(bibliographic_metadata)
+        refs = bibliographic_metadata.dig("citation_list", "citation")
+        Array.wrap(refs).select { |a| a["doi"].present? }.map do |c|
+          if c["doi"].present?
+            { "relatedIdentifier" => parse_attributes(c["doi"]).downcase,
+              "relationType" => "References",
+              "relatedIdentifierType" => "DOI" }.compact
+          else
+            nil
+          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
+
+      def crossref_is_related_material(program_metadata)
+        refs = program_metadata.dig("related_item") if program_metadata.is_a?(Hash)
+        Array.wrap(refs).select { |a| a.dig("interwork_relation", "relationship_type") == "isRelatedMaterial" }.map do |c|
+          if c.dig("inter_work_relation", "identifier_type") == "doi"
+            { "relatedIdentifier" => parse_attributes(c["inter_work_relation"]).downcase,
+              "relationType" => "Other",
+              "relatedIdentifierType" => "DOI" }.compact
+          else
+            nil
+          end
+        end.compact.unwrap
+      end
+    end
+  end
+end