bolognese 1.0.29 → 1.0.30

data/lib/bolognese/readers/citeproc_reader.rb

@@ -45,7 +45,7 @@ module Bolognese
           "bibtex" => Bolognese::Utils::SO_TO_BIB_TRANSLATIONS[schema_org] || "misc",
           "ris" => CP_TO_RIS_TRANSLATIONS[schema_org] || "GEN"
         }.compact
-        doi = normalize_doi(meta.fetch("DOI", nil))
+
         creators = get_authors(from_citeproc(Array.wrap(meta.fetch("author", nil))))
         contributors = get_authors(from_citeproc(Array.wrap(meta.fetch("editor", nil))))
         dates = if meta.fetch("issued", nil).present?
@@ -69,33 +69,54 @@ module Bolognese
         else
           nil
         end
-        periodical = if meta.fetch("container-title", nil).present?
+        container = if meta.fetch("container-title", nil).present?
+          first_page = meta.fetch("page", nil).present? ? meta.fetch("page").split("-").map(&:strip).first : nil
+          last_page = meta.fetch("page", nil).present? ? meta.fetch("page").split("-").map(&:strip).last : nil
+
           { "type" => "Periodical",
             "title" => meta.fetch("container-title", nil),
-            "issn" => meta.fetch("ISSN", nil) }.compact
+            "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))
+
+        identifiers = [normalize_id(meta.fetch("id", nil)), normalize_doi(meta.fetch("DOI", nil))].compact.map do |r|
+          r = normalize_id(r)
+
+          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 }
         end
 
         { "id" => id,
+          "identifiers" => identifiers,
           "types" => types,
           "doi" => doi_from_url(doi),
           "url" => normalize_id(meta.fetch("URL", nil)),
           "titles" => [{ "title" => meta.fetch("title", nil) }],
           "creators" => creators,
           "contributors" => contributors,
-          "periodical" => periodical,
+          "container" => container,
           "publisher" => meta.fetch("publisher", nil),
           "related_identifiers" => related_identifiers,
           "dates" => dates,
           "publication_year" => publication_year,
-          "volume" => meta.fetch("volume", nil),
-          #{}"pagination" => meta.pages.to_s.presence,
           "descriptions" => meta.fetch("abstract", nil).present? ? [{ "description" => sanitize(meta.fetch("abstract")), "descriptionType" => "Abstract" }] : [],
           "rights_list" => rights_list,
           "version_info" => meta.fetch("version", nil),

data/lib/bolognese/readers/codemeta_reader.rb

@@ -21,10 +21,23 @@ module Bolognese
         read_options = ActiveSupport::HashWithIndifferentAccess.new(options.except(:doi, :id, :url, :sandbox, :validate))
 
         meta = string.present? ? Maremma.from_json(string) : {}
-        identifier = meta.fetch("identifier", nil)
-        id = normalize_id(meta.fetch("@id", nil) || identifier)
-        author = get_authors(from_schema_org(Array.wrap(meta.fetch("agents", nil))))
-        contributor = get_authors(from_schema_org(Array.wrap(meta.fetch("editor", nil))))
+
+        identifiers = ([meta.fetch("@id", nil)] + 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)
+              { "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)
+
+        creators = get_authors(from_schema_org_creators(Array.wrap(meta.fetch("agents", nil))))
+        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?
@@ -47,12 +60,12 @@ module Bolognese
 
         { "id" => id,
           "types" => types,
-          "identifier" => identifier,
-          "doi" => validate_doi(id),
+          "identifiers" => identifiers,
+          "doi" => doi_from_url(doi),
           "url" => normalize_id(meta.fetch("codeRepository", nil)),
           "titles" => [{ "title" => meta.fetch("title", nil) }],
-          "creators" => author,
-          "contributors" => contributor,
+          "creators" => creators,
+          "contributors" => contributors,
           "publisher" => publisher,
           #{}"is_part_of" => is_part_of,
           "dates" => dates,

data/lib/bolognese/readers/crossref_reader.rb

@@ -72,7 +72,7 @@ module Bolognese
           bibliographic_metadata = meta.dig("crossref", "sa_component", "component_list", "component").to_h
         end
 
-        resource_type = (resource_type || model).to_s.underscore.camelize.presence
+        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],
@@ -82,7 +82,6 @@ module Bolognese
           "bibtex" => Bolognese::Utils::CR_TO_BIB_TRANSLATIONS[resource_type] || "misc",
           "ris" => Bolognese::Utils::CR_TO_RIS_TRANSLATIONS[resource_type] || "JOUR"
         }.compact
-        doi = bibliographic_metadata.dig("doi_data", "doi").to_s.downcase.presence #|| doi_from_url(options[:id])
 
         # Crossref servers run on Eastern Time
         Time.zone = 'Eastern Time (US & Canada)'
@@ -96,33 +95,41 @@ module Bolognese
         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))
-        periodical = if journal_metadata.present?
-            { "type" => "Periodical",
-              "issn" => parse_attributes(journal_metadata.fetch("issn", nil), first: true),
-              "title" => journal_metadata["full_title"] }.compact
+        container = if journal_metadata.present? || book_metadata.present?
+          issn = parse_attributes(journal_metadata.to_h.fetch("issn", nil), first: true)
+
+          { "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
         else
           nil
         end
 
-        { "id" => normalize_doi(doi),
+        identifiers = [{ "identifierType" => "DOI", "identifier" => normalize_doi(options[:doi] || options[:id] || bibliographic_metadata.dig("doi_data", "doi")) }, crossref_alternate_identifiers(bibliographic_metadata)].compact
+
+        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" => id,
           "types" => types,
-          "doi" => doi,
+          "doi" => doi_from_url(doi),
           "url" => bibliographic_metadata.dig("doi_data", "resource"),
           "titles" => [{ "title" => parse_attributes(bibliographic_metadata.dig("titles", "title")) }],
-          "alternate_identifiers" => crossref_alternate_identifiers(bibliographic_metadata),
+          "identifiers" => identifiers,
           "creators" => crossref_people(bibliographic_metadata, "author"),
           "contributors" => crossref_people(bibliographic_metadata, "editor"),
           "funding_references" => crossref_funding_reference(program_metadata),
           "publisher" => publisher,
-          "periodical" => periodical,
+          "container" => container,
           "agency" => "Crossref",
           "related_identifiers" => related_identifiers,
           "dates" => dates,
           "publication_year" => publication_year,
-          "volume" => journal_issue.dig("journal_volume", "volume"),
-          "issue" => journal_issue.dig("issue"),
-          "first_page" => bibliographic_metadata.dig("pages", "first_page"),
-          "last_page" => bibliographic_metadata.dig("pages", "last_page"),
           "descriptions" => crossref_description(bibliographic_metadata),
           "rights_list" => crossref_license(program_metadata),
           "version_info" => nil,
@@ -135,12 +142,12 @@ module Bolognese
       end
 
       def crossref_alternate_identifiers(bibliographic_metadata)
-        if bibliographic_metadata.fetch("publisher_item", nil).present?
-          { "alternateIdentifier" => parse_attributes(bibliographic_metadata.dig("publisher_item", "item_number")),
-            "alternateIdentifierType" => "Publisher ID" }
-        else
-          { "alternateIdentifier" => parse_attributes(bibliographic_metadata.fetch("item_number", nil)),
-            "alternateIdentifierType" => "Publisher ID" }
+        if bibliographic_metadata.dig("publisher_item", "item_number").present?
+          { "identifier" => parse_attributes(bibliographic_metadata.dig("publisher_item", "item_number")),
+            "identifierType" => "Publisher ID" }
+        elsif parse_attributes(bibliographic_metadata.fetch("item_number", nil)).present?
+          { "identifier" => parse_attributes(bibliographic_metadata.fetch("item_number", nil)),
+            "identifierType" => "Publisher ID" }
         end
       end
 
@@ -170,9 +177,10 @@ module Bolognese
       def crossref_people(bibliographic_metadata, contributor_role)
         person = bibliographic_metadata.dig("contributors", "person_name")
         Array.wrap(person).select { |a| a["contributor_role"] == contributor_role }.map do |a|
-          { "type" => "Person",
-            "id" => parse_attributes(a["ORCID"]),
-            "name" => [a["given_name"], a["surname"]].join(" "),
+          name_identifiers = normalize_orcid(parse_attributes(a["ORCID"])).present? ? [{ "nameIdentifier" => normalize_orcid(parse_attributes(a["ORCID"])), "nameIdentifierScheme" => "ORCID" }] : nil
+          { "nameType" => "Personal",
+            "nameIdentifiers" => name_identifiers,
+            "name" => [a["surname"], a["given_name"]].join(", "),
             "givenName" => a["given_name"],
             "familyName" => a["surname"],
             "contributorType" => contributor_role == "editor" ? "Editor" : nil }.compact

data/lib/bolognese/readers/datacite_json_reader.rb

@@ -7,53 +7,7 @@ module Bolognese
         errors = jsonlint(string)
         return { "errors" => errors } if errors.present?
 
-        read_options = ActiveSupport::HashWithIndifferentAccess.new(options.except(:doi, :id, :url, :sandbox, :validate))
-
-        meta = string.present? ? Maremma.from_json(string) : {}
-
-        state = meta.fetch("doi", nil).present? || read_options.present? ? "findable" : "not_found"
-
-        dates = Array.wrap(meta.fetch("dates", nil)).map do |d|
-          { "date" => d["date"],
-            "dateType" => d["dateType"],
-            "dateInformation" => d["dateInformation"] }.compact
-        end
-        dates << { "date" => meta.fetch("publicationYear", nil), "dateType" => "Issued" } if meta.fetch("publicationYear", nil).present? && get_date(dates, "Issued").blank?
-        schema_org = meta.dig("types", "type") || Bolognese::Utils::CR_TO_SO_TRANSLATIONS[meta.dig("types", "resourceType").to_s.underscore.camelcase] || Bolognese::Utils::DC_TO_SO_TRANSLATIONS[meta.dig("types", "resourceTypeGeneral").to_s.dasherize] || "CreativeWork"
-        types = { 
-          "resourceTypeGeneral" => meta.dig("types", "resourceTypeGeneral"),
-          "resourceType" => meta.dig("types", "resourceType"),
-          "schemaOrg" => schema_org,
-          "bibtex" => meta.dig("types", "bibtex") || Bolognese::Utils::CR_TO_BIB_TRANSLATIONS[meta.dig("types", "resourceType").to_s.underscore.camelcase] || Bolognese::Utils::SO_TO_BIB_TRANSLATIONS[schema_org] || "misc",
-          "citeproc" => meta.dig("types", "citeproc") || Bolognese::Utils::CR_TO_CP_TRANSLATIONS[meta.dig("types", "resourceType").to_s.underscore.camelcase] || Bolognese::Utils::SO_TO_CP_TRANSLATIONS[schema_org] || "article",
-          "ris" => meta.dig("types", "ris") || Bolognese::Utils::CR_TO_RIS_TRANSLATIONS[meta.dig("types", "resourceType").to_s.underscore.camelcase] || Bolognese::Utils::DC_TO_RIS_TRANSLATIONS[meta.dig("types", "resourceTypeGeneral").to_s.dasherize] || "GEN" }.compact
-
-        { "id" => meta.fetch("id", nil),
-          "types" => types,
-          "doi" => validate_doi(meta.fetch("doi", nil)),
-          "url" => normalize_id(meta.fetch("url", nil)),
-          "titles" => meta.fetch("titles", nil),
-          "alternate_identifiers" => Array.wrap(meta.fetch("alternateIdentifiers", nil)),
-          "creators" => meta.fetch("creators", nil),
-          "contributors" => meta.fetch("contributors", nil),
-          "publisher" => meta.fetch("publisher", nil),
-          "periodical" => meta.fetch("periodical", nil),
-          "agency" => "DataCite",
-          "funding_references" => meta.fetch("fundingReferences", nil),
-          "related_identifiers" => Array.wrap(meta.fetch("relatedIdentifiers", nil)),
-          "dates" => dates,
-          "publication_year" => meta.fetch("publicationYear", nil),
-          "descriptions" => meta.fetch("descriptions", nil),
-          "rights_list" => meta.fetch("rightsList", nil),
-          "version_info" => meta.fetch("version", nil),
-          "subjects" => meta.fetch("subjects", nil),
-          "language" => meta.fetch("language", nil),
-          "sizes" => meta.fetch("sizes", nil),
-          "formats" => meta.fetch("formats", nil),
-          "geo_locations" => meta.fetch("geoLocations", nil),
-          "schema_version" => meta.fetch("schemaVersion", nil),
-          "state" => state
-        }.merge(read_options)
+        string.present? ? Maremma.from_json(string).transform_keys! { |key| key.underscore } : {}
       end
     end
   end

data/lib/bolognese/readers/datacite_reader.rb

@@ -76,7 +76,11 @@ module Bolognese
           id = normalize_doi(meta.dig("identifier", "__content__") || options[:id], sandbox: options[:sandbox])
         end
 
-        doi = doi_from_url(id)
+        identifiers = [{ "identifierType" => "DOI", "identifier" => id }] + Array.wrap(meta.dig("alternateIdentifiers", "alternateIdentifier")).map do |r|
+          { "identifierType" => get_identifier_type(r["alternateIdentifierType"]), "identifier" => r["__content__"].presence }.compact
+        end.compact
+
+        doi = Array.wrap(identifiers).find { |r| r["identifierType"] == "DOI" }.to_h.fetch("identifier", nil)
 
         resource_type_general = meta.dig("resourceType", "resourceTypeGeneral")
         resource_type = meta.dig("resourceType", "__content__")
@@ -100,9 +104,6 @@ module Bolognese
           end
         end.compact
 
-        alternate_identifiers = Array.wrap(meta.dig("alternateIdentifiers", "alternateIdentifier")).map do |r|
-          { "alternateIdentifierType" => r["alternateIdentifierType"], "alternateIdentifier" => r["__content__"].presence }.compact
-        end.compact
         descriptions = Array.wrap(meta.dig("descriptions", "description")).map do |r|
           if r.blank?
             nil
@@ -167,7 +168,7 @@ module Bolognese
           }.compact
         end
         geo_locations = Array.wrap(meta.dig("geoLocations", "geoLocation")).map do |gl|
-          if !gl.is_a?(Hash) || gl["geoLocationPoint"].is_a?(String) || gl["geoLocationBox"].is_a?(String)
+          if !gl.is_a?(Hash) || gl["geoLocationPoint"].is_a?(String) || gl["geoLocationBox"].is_a?(String) || gl["geoLocationPolygon"].is_a?(String)
             nil
           else
             {
@@ -181,22 +182,23 @@ module Bolognese
                 "southBoundLatitude" => gl.dig("geoLocationBox", "southBoundLatitude"),
                 "northBoundLatitude" => gl.dig("geoLocationBox", "northBoundLatitude")
               }.compact.presence,
+              "geoLocationPolygon" => Array.wrap(gl.dig("geoLocationPolygon", "polygonPoint")).map { |glp| { "polygonPoint" => glp } }.compact.presence,
               "geoLocationPlace" => parse_attributes(gl["geoLocationPlace"], first: true).to_s.strip.presence
             }.compact
           end
         end.compact
-        periodical = set_periodical(meta)
+        container = set_container(meta)
         state = doi.present? || read_options.present? ? "findable" : "not_found"
 
         { "id" => id,
           "types" => types,
-          "doi" => doi,
-          "alternate_identifiers" => alternate_identifiers,
+          "doi" => doi_from_url(doi),
+          "identifiers" => identifiers,
           "url" => options.fetch(:url, nil).to_s.strip.presence,
           "titles" => titles,
           "creators" => get_authors(Array.wrap(meta.dig("creators", "creator"))),
           "contributors" => get_authors(Array.wrap(meta.dig("contributors", "contributor"))),
-          "periodical" => periodical,
+          "container" => container,
           "publisher" => parse_attributes(meta.fetch("publisher", nil), first: true).to_s.strip.presence,
           "agency" => "DataCite",
           "funding_references" => funding_references,
@@ -216,17 +218,25 @@ module Bolognese
         }.merge(read_options)
       end
 
-      def set_periodical(meta)
-        container_title = Array.wrap(meta.dig("descriptions", "description")).find { |r| r["descriptionType"] == "SeriesInformation" }.to_h.fetch("__content__", nil)
+      def set_container(meta)
+        series_information = Array.wrap(meta.dig("descriptions", "description")).find { |r| r["descriptionType"] == "SeriesInformation" }.to_h.fetch("__content__", nil)
+        si = get_series_information(series_information)
+
         is_part_of = Array.wrap(meta.dig("relatedIdentifiers", "relatedIdentifier")).find { |ri| ri["relationType"] == "IsPartOf" }.to_h
 
-        if container_title.present? || is_part_of.present?
+        if si["title"].present? || is_part_of.present?
           {
-            "type" => meta.dig("resourceType", "resourceTypeGeneral") == "Dataset" ? "DataCatalog" : "Periodical",
-            "id" => is_part_of["relatedIdentifierType"] == "DOI" ? normalize_doi(is_part_of["__content__"]) : is_part_of["__content__"],
-            "title" => container_title,
-            "issn" => is_part_of["relatedIdentifierType"] == "ISSN" ? is_part_of["__content__"] : nil
+            "type" => meta.dig("resourceType", "resourceTypeGeneral") == "Dataset" ? "DataRepository" : "Series",
+            "identifier" => is_part_of["__content__"],
+            "identifierType" => is_part_of["relatedIdentifierType"],
+            "title" => si["title"],
+            "volume" => si["volume"],
+            "issue" => si["issue"],
+            "firstPage" => si["firstPage"],
+            "lastPage" => si["lastPage"]
           }.compact
+        else
+          {}
         end
       end
     end

data/lib/bolognese/readers/ris_reader.rb

@@ -47,8 +47,14 @@ module Bolognese
           "ris" => ris_type
         }.compact
 
-        doi = validate_doi(meta.fetch("DO", nil))
-        author = Array.wrap(meta.fetch("AU", nil)).map { |a| { "name" => a } }
+        identifiers = [normalize_doi(options[:doi]) || normalize_doi(meta.fetch("DO", nil))].map do |r|
+          { "identifierType" => "DOI", "identifier" => normalize_id(r) }
+        end.compact
+
+        id = Array.wrap(identifiers).first.to_h.fetch("identifier", nil)
+        doi = Array.wrap(identifiers).find { |r| r["identifierType"] == "DOI" }.to_h.fetch("identifier", nil)
+
+        author = Array.wrap(meta.fetch("AU", nil)).map { |a| { "creatorName" => a } }
         date_parts = meta.fetch("PY", nil).to_s.split("/")
         created_date_parts = meta.fetch("Y1", nil).to_s.split("/")
         dates = []
@@ -64,34 +70,35 @@ module Bolognese
         else
           []
         end
-        periodical = if meta.fetch("T2", nil).present?
-          { "type" => "Periodical",
+        container = if meta.fetch("T2", nil).present?
+          { "type" => "Journal",
             "title" => meta.fetch("T2", nil), 
-            "id" => meta.fetch("SN", nil) }.compact
+            "identifier" => meta.fetch("SN", nil),
+            "volume" => meta.fetch("VL", nil),
+            "issue" => meta.fetch("IS", nil),
+            "firstPage" => meta.fetch("SP", nil),
+            "lastPage" => meta.fetch("EP", nil) }.compact
         else
           nil
         end
-        state = doi.present? || read_options.present? ? "findable" : "not_found"
+        state = meta.fetch("DO", nil).present? || read_options.present? ? "findable" : "not_found"
         subjects = Array.wrap(meta.fetch("KW", nil)).map do |s|
           { "subject" => s }
         end
 
-        { "id" => normalize_doi(doi),
+        { "id" => id,
           "types" => types,
-          "doi" => doi,
+          "identifiers" => identifiers,
+          "doi" => doi_from_url(doi),
           "url" => meta.fetch("UR", nil),
           "titles" => meta.fetch("T1", nil).present? ? [{ "title" => meta.fetch("T1", nil) }] : nil,
           "creators" => get_authors(author),
           "publisher" => meta.fetch("PB", "(:unav)"),
-          "periodical" => periodical,
+          "container" => container,
           "related_identifiers" => related_identifiers,
           "dates" => dates,
           "publication_year" => publication_year,
           "descriptions" => meta.fetch("AB", nil).present? ? [{ "description" => sanitize(meta.fetch("AB")), "descriptionType" => "Abstract" }] : nil,
-          "volume" => meta.fetch("VL", nil),
-          "issue" => meta.fetch("IS", nil),
-          "first_page" => meta.fetch("SP", nil),
-          "last_page" => meta.fetch("EP", nil),
           "subjects" => subjects,
           "language" => meta.fetch("LA", nil),
           "state" => state

data/lib/bolognese/readers/schema_org_reader.rb

@@ -37,21 +37,19 @@ module Bolognese
 
         meta = string.present? ? Maremma.from_json(string) : {}
 
-        identifier = Array.wrap(meta.fetch("identifier", nil))
-        if identifier.length > 1
-          alternate_identifiers = identifier[1..-1].map do |r|
-            if r.is_a?(String)
-              { "alternateIdentifierType" => "URL", "alternateIdentifier" => r }
-            elsif r.is_a?(Hash)
-              { "alternateIdentifierType" => r["propertyID"], "alternateIdentifier" => r["value"] }
-            end
+        identifiers = ([options[:doi] || meta.fetch("@id", nil)] + 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)
+              { "identifierType" => "URL", "identifier" => r }
+          elsif r.is_a?(Hash)
+            { "identifierType" => get_identifier_type(r["propertyID"]), "identifier" => r["value"] }
           end
-        else
-          alternate_identifiers = nil
-        end
-        identifier = identifier.first
+        end.compact.uniq
+
+        id = Array.wrap(identifiers).first.to_h.fetch("identifier", nil)
 
-        id = normalize_id(meta.fetch("@id", nil) || meta.fetch("identifier", nil))
         schema_org = meta.fetch("@type", nil) && meta.fetch("@type").camelcase
         resource_type_general = Bolognese::Utils::SO_TO_DC_TRANSLATIONS[schema_org]
         types = {
@@ -63,19 +61,26 @@ module Bolognese
           "ris" => Bolognese::Utils::SO_TO_RIS_TRANSLATIONS[resource_type_general.to_s.dasherize] || "GEN"
         }.compact
         authors = meta.fetch("author", nil) || meta.fetch("creator", nil)
-        creators = get_authors(from_schema_org(Array.wrap(authors)))
-        contributors = get_authors(from_schema_org(Array.wrap(meta.fetch("editor", nil))))
+        creators = get_authors(from_schema_org_creators(Array.wrap(authors)))
+        contributors = get_authors(from_schema_org_contributors(Array.wrap(meta.fetch("editor", nil))))
         publisher = parse_attributes(meta.fetch("publisher", nil), content: "name", first: true)
 
         ct = (schema_org == "Dataset") ? "includedInDataCatalog" : "Periodical"
-        periodical = if meta.fetch(ct, nil).present?
+        container = if meta.fetch(ct, nil).present?
+          url =  parse_attributes(from_schema_org(meta.fetch(ct, nil)), content: "url", first: true)
+          
           {
-            "type" => (schema_org == "Dataset") ? "DataCatalog" : "Periodical",
+            "type" => (schema_org == "Dataset") ? "DataRepository" : "Periodical",
             "title" => parse_attributes(from_schema_org(meta.fetch(ct, nil)), content: "name", first: true),
-            "url" => parse_attributes(from_schema_org(meta.fetch(ct, nil)), content: "url", first: true)
+            "identifier" => url,
+            "identifierType" => url.present? ? "URL" : nil,
+            "volume" => meta.fetch("volumeNumber", nil),
+            "issue" => meta.fetch("issueNumber", nil),
+            "firstPage" => meta.fetch("pageStart", nil),
+            "lastPage" => meta.fetch("pageEnd", nil)
           }.compact
         else
-          nil
+          {}
         end
 
         related_identifiers = Array.wrap(schema_org_is_identical_to(meta)) +
@@ -138,8 +143,7 @@ module Bolognese
         { "id" => id,
           "types" => types,
           "doi" => validate_doi(id),
-          "identifier" => identifier,
-          "alternate_identifiers" => alternate_identifiers,
+          "identifiers" => identifiers,
           "url" => normalize_id(meta.fetch("url", nil)),
           "content_url" => Array.wrap(meta.fetch("contentUrl", nil)),
           "sizes" => Array.wrap(meta.fetch("contenSize", nil)).presence,
@@ -149,7 +153,7 @@ module Bolognese
           "contributors" => contributors,
           "publisher" => publisher,
           "agency" => parse_attributes(meta.fetch("provider", nil), content: "name", first: true),
-          "periodical" => periodical,
+          "container" => container,
           "related_identifiers" => related_identifiers,
           "publication_year" => publication_year,
           "dates" => dates,