datacite 0.6.0 → 0.8.0

data/lib/datacite/mapping/from_cocina/contributor_attributes.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module Datacite
+  module Mapping
+    module FromCocina
+      # Transform the Cocina::Models::Description to contributor attributes
+      #  see https://support.datacite.org/reference/dois-2#put_dois-id
+      class ContributorAttributes # rubocop:disable Metrics/ClassLength
+        DATACITE_PERSON_CONTRIBUTOR_TYPES = {
+          'copyright holder' => 'RightsHolder',
+          'compiler' => 'DataCollector',
+          'editor' => 'Editor',
+          'organizer' => 'Supervisor',
+          'research team head' => 'ProjectLeader',
+          'researcher' => 'Researcher'
+        }.freeze
+
+        DATACITE_ORGANIZATION_CONTRIBUTOR_TYPES = {
+          'copyright holder' => 'RightsHolder',
+          'compiler' => 'DataCollector',
+          'distributor' => 'Distributor',
+          'host institution' => 'HostingInstitution',
+          'issuing body' => 'Distributor',
+          'publisher' => 'Distributor',
+          'researcher' => 'ResearchGroup',
+          'sponsor' => 'Sponsor'
+        }.freeze
+
+        # @param [Cocina::Models::Description] description
+        # @return [Hash] Hash of DataCite attributes containing creators, contributors, and fundingReferences keys
+        def self.build(...)
+          new(...).call
+        end
+
+        def initialize(description:)
+          @description = description
+        end
+
+        # @return [Hash] Hash of DataCite attributes containing creators, contributors, and fundingReferences keys
+        def call
+          {
+            creators: datacite_creators,
+            contributors: datacite_contributors,
+            fundingReferences: datacite_funders
+          }
+        end
+
+        private
+
+        attr_reader :description
+
+        def cocina_creators
+          @cocina_creators ||= Array(description.contributor).select do |cocina_contributor|
+            datacite_creator?(cocina_contributor)
+          end
+        end
+
+        def cocina_contributors
+          @cocina_contributors ||= Array(description.contributor).select do |cocina_contributor|
+            datacite_contributor?(cocina_contributor)
+          end
+        end
+
+        def cocina_funders
+          @cocina_funders ||= Array(description.contributor).select do |cocina_contributor|
+            datacite_funder?(cocina_contributor)
+          end
+        end
+
+        def datacite_creator?(cocina_contributor)
+          !datacite_funder?(cocina_contributor) && !datacite_contributor?(cocina_contributor)
+        end
+
+        def datacite_funder?(cocina_contributor)
+          marc_relator(cocina_contributor) == 'funder'
+        end
+
+        def datacite_contributor?(cocina_contributor)
+          marc_relator(cocina_contributor) == 'publisher' || degree_committee_member?(cocina_contributor)
+        end
+
+        def datacite_creators
+          @datacite_creators ||= cocina_creators.map { |cocina_creator| datacite_creator(cocina_creator) }.uniq
+        end
+
+        def datacite_contributors
+          @datacite_contributors ||= cocina_contributors.map do |cocina_contributor|
+            datacite_contributor(cocina_contributor)
+          end.uniq
+        end
+
+        def datacite_funders
+          @datacite_funders ||= cocina_funders.map { |cocina_funder| { funderName: cocina_funder.name.first.value } }
+        end
+
+        def datacite_creator(cocina_contributor)
+          return personal_name(cocina_contributor) if person?(cocina_contributor)
+
+          organizational_name(cocina_contributor)
+        end
+
+        def person?(cocina_contributor)
+          cocina_contributor.type == 'person'
+        end
+
+        def datacite_contributor(cocina_contributor)
+          datacite_creator(cocina_contributor).merge({ contributorType: contributor_type(cocina_contributor) })
+        end
+
+        def personal_name(cocina_contributor) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          {
+            nameType: 'Personal',
+            nameIdentifiers: name_identifiers(cocina_contributor).presence,
+            affiliation: affiliations(cocina_contributor).presence
+          }.tap do |name_hash|
+            # NOTE: This is needed for ETDs, for which we do not receive structured
+            #       contributor names from Axess for ETD readers
+            if cocina_contributor.name.first.structuredValue.empty?
+              name_hash[:name] = cocina_contributor.name.first.value
+            elsif (name = cocina_contributor.name.first.structuredValue.find { |part| part.type == 'name' }).present?
+              name_hash[:name] = name.value
+            else
+              forename = cocina_contributor.name.first.structuredValue.find { |part| part.type == 'forename' }
+              surname = cocina_contributor.name.first.structuredValue.find { |part| part.type == 'surname' }
+
+              name_hash[:name] = "#{surname.value}, #{forename.value}"
+              name_hash[:givenName] = forename.value
+              name_hash[:familyName] = surname.value
+            end
+          end
+            .compact
+        end
+
+        def organizational_name(cocina_contributor)
+          name = cocina_contributor.name.first.structuredValue.first || cocina_contributor.name.first
+          {
+            name: name.value,
+            nameType: 'Organizational',
+            nameIdentifiers: name_identifiers(name).presence
+          }.compact
+        end
+
+        def name_identifiers(cocina_contributor)
+          Array(cocina_contributor.identifier).map do |identifier|
+            {
+              nameIdentifier: identifier.value || identifier.uri,
+              nameIdentifierScheme: identifier.type,
+              schemeURI: identifier.source.uri
+            }.compact
+          end
+        end
+
+        def affiliations(cocina_contributor) # rubocop:disable Metrics/MethodLength
+          Array(cocina_contributor.affiliation).map do |affiliation|
+            institution = affiliation.structuredValue.find { |descriptive_value| descriptive_value.identifier.present? }
+            institution ||= affiliation # if no structured value with identifier, use the affiliation itself
+            identifier = institution.identifier.find { |id| id.type == 'ROR' }
+            next unless identifier&.uri
+
+            {
+              affiliationIdentifier: identifier.uri,
+              affiliationIdentifierScheme: 'ROR',
+              name: institution.value,
+              schemeUri: 'https://ror.org/'
+            }.compact
+          end
+        end
+
+        def contributor_type(cocina_contributor)
+          if person?(cocina_contributor)
+            return DATACITE_PERSON_CONTRIBUTOR_TYPES.fetch(marc_relator(cocina_contributor),
+                                                           'Other')
+          end
+
+          DATACITE_ORGANIZATION_CONTRIBUTOR_TYPES.fetch(marc_relator(cocina_contributor), 'Other')
+        end
+
+        # NOTE: This is how ETDs map to Cocina by way of MARC21 to MODS, where the
+        #       700$e and 700$4 subfields cannot be interpreted as pertaining to
+        #       the same role, so the Cocina winds up expressing this as two
+        #       roles, e.g.:
+        #
+        #   role: [
+        #     {
+        #       value: "degree committee member",
+        #     },
+        #     {
+        #       code: "ths",
+        #       source: {
+        #         code: "marcrelator",
+        #       },
+        #     }
+        #   ]
+        def degree_committee_member?(cocina_contributor)
+          cocina_contributor.role.any? { |contrib_role| contrib_role.value == 'degree committee member' } &&
+            cocina_contributor.role.any? do |contrib_role|
+              contrib_role.code == 'ths' && contrib_role.source.code == 'marcrelator'
+            end
+        end
+
+        def marc_relator(cocina_contributor)
+          Array(cocina_contributor.role).find do |role|
+            role&.source&.code == 'marcrelator'
+          end&.value
+        end
+      end
+    end
+  end
+end

data/lib/datacite/mapping/from_cocina/date.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Datacite
+  module Mapping
+    module FromCocina
+      # Transform the Cocina::Models::DRO.description.event attributes to appropriate DataCite attributes
+      #  see https://support.datacite.org/reference/dois-2#put_dois-id
+      class Date # rubocop:disable Metrics/ClassLength
+        # @param [Cocina::Models::DRO] cocina_object
+        def self.build(...)
+          new(...).call
+        end
+
+        def initialize(cocina_object:)
+          @cocina_object = cocina_object
+        end
+
+        # DataCite publicationYear is the year (YYYY) the object is published to purl, and is either:
+        ## The embargo end date, if present (cocina event type release, date type publication)
+        ## The deposit date (cocina event type deposit, date type publication)
+        #
+        # @return [String] publication year, conforming to the expectations of HTTP PUT request to DataCite
+        def pub_year # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          if embargo?
+            embargo_release_date = cocina_dro_access&.embargo&.releaseDate
+            embargo_release_date&.year&.to_s
+          elsif deposit_event_publication_date_value
+            DateTime.parse(deposit_event_publication_date_value).year&.to_s
+          end
+        end
+
+        # H2 publisher role > same cocina event as publication date > see DataCite contributor mappings
+        # Add Stanford Digital Repository as publisher to cocina release event if present, otherwise deposit event
+        #
+        # sdr is the publisher for the event where the content becomes public via purl -- deposit if no embargo,
+        # release if embargo present.
+        # if it's not public via purl, sdr should not be the publisher;
+        #   the user may enter someone with the publisher role in h2, referring to publication in another venue,
+        #   regardless of the purl status.
+        def publisher
+          # TODO: implement this
+        end
+
+        # DataCite date (YYYY-MM-DD) is repeatable and each DataCite data has an associated type attribute
+        # @return [Array<Hash>] DataCite date hashs, conforming to the expectations of HTTP PUT request to DataCite
+        def call # rubocop:disable Metrics/AbcSize
+          [].tap do |dates|
+            dates << submitted_date if submitted_date.present?
+            dates << available_date if available_date.present?
+            dates << issued_date if issued_date.present?
+            dates << created_date if created_date.present?
+          end
+        end
+
+        private
+
+        attr_reader :cocina_object
+
+        def embargo?
+          cocina_dro_access&.embargo&.releaseDate.presence
+        end
+
+        # If embargo,
+        #   Cocina event type deposit, date type deposit maps to DataCite date type Submitted
+        # If no embargo
+        #   Cocina event type deposit, date type publication maps to DataCite date type Submitted
+        # If no embargo and no deposit event with date type publication,
+        #   Cocina event type publication, date type publication maps to DataCite date type Submitted
+        def submitted_date # rubocop:disable Metrics/AbcSize
+          @submitted_date ||= {}.tap do |submitted_date|
+            if embargo? && deposit_event_deposit_date_value.present?
+              submitted_date[:date] = deposit_event_deposit_date_value
+            elsif deposit_event_publication_date_value.present? # no embargo
+              submitted_date[:date] = deposit_event_publication_date_value
+            elsif publication_event_publication_date_value.present? # no embargo
+              submitted_date[:date] = publication_event_publication_date_value
+            end
+            submitted_date[:dateType] = 'Submitted' if submitted_date.present?
+          end
+        end
+
+        # from Arcadia:
+        #   Cocina event type release, date type publication maps to DataCite date type Available
+        # In actuality:
+        #   embargo release date is in DROAccess, not in an event
+        def available_date
+          return unless embargo?
+
+          @available_date ||=
+            {
+              date: cocina_dro_access&.embargo&.releaseDate.to_s,
+              dateType: 'Available'
+            }
+        end
+
+        # Cocina event type publication, date type publication maps to DataCite date type Issued
+        def issued_date
+          return if publication_event_publication_date_value.blank?
+
+          @issued_date ||=
+            {
+              date: publication_event_publication_date_value,
+              dateType: 'Issued'
+            }
+        end
+
+        # Cocina event type creation, date type creation maps to DataCite date type Created
+        def created_date # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          return if creation_event_creation_date.blank?
+
+          @created_date ||= begin
+            created_date = {
+              dateType: 'Created'
+            }
+            if creation_event_creation_date.value
+              created_date[:date] = creation_event_creation_date.value
+              if creation_event_creation_date.qualifier.present?
+                created_date[:dateInformation] =
+                  creation_event_creation_date.qualifier
+              end
+            else
+              created_date.merge!(structured_date_result(creation_event_creation_date))
+            end
+
+            created_date
+          end
+        end
+
+        def deposit_event_deposit_date_value
+          @deposit_event_deposit_date_value ||= deposit_event&.date&.find { |date| date&.type == 'deposit' }&.value
+        end
+
+        def deposit_event_publication_date_value
+          @deposit_event_publication_date_value ||= deposit_event&.date&.find do |date|
+            date&.type == 'publication'
+          end&.value
+        end
+
+        def deposit_event
+          @deposit_event ||= cocina_events&.find { |event| event&.type == 'deposit' }
+        end
+
+        def publication_event_publication_date_value
+          @publication_event_publication_date_value ||= publication_event&.date&.find do |date|
+            date&.type == 'publication'
+          end&.value
+        end
+
+        def publication_event
+          @publication_event ||= cocina_events&.find { |event| event&.type == 'publication' }
+        end
+
+        def creation_event_creation_date
+          @creation_event_creation_date ||= creation_event&.date&.find { |date| date&.type == 'creation' }
+        end
+
+        def creation_event
+          @creation_event ||= cocina_events&.find { |event| event&.type == 'creation' }
+        end
+
+        def structured_date_result(date) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          return unless date.structuredValue
+
+          start_date, end_date, = ''
+          info = date.qualifier if date.qualifier.present?
+          date.structuredValue.each do |structured_val|
+            start_date = structured_val.value if structured_val.type == 'start'
+            end_date = structured_val.value if structured_val.type == 'end'
+            info = structured_val.qualifier if structured_val.qualifier
+          end
+
+          result_date = if start_date.present? && end_date.present?
+                          "#{start_date}/#{end_date}"
+                        elsif start_date.present?
+                          start_date
+                        elsif end_date.present?
+                          end_date
+                        end
+
+          {
+            date: result_date
+          }.tap do |attributes|
+            attributes[:dateInformation] = info if info.present? && result_date.present?
+          end.compact
+        end
+
+        def cocina_events
+          @cocina_events ||= cocina_object.description.event
+        end
+
+        # embargo is in Cocina::Models::DROAccess -- the top level access, not description.access
+        def cocina_dro_access
+          @cocina_dro_access ||= cocina_object.access
+        end
+      end
+    end
+  end
+end

data/lib/datacite/mapping/from_cocina/descriptions.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Datacite
+  module Mapping
+    module FromCocina
+      # Transform the Cocina::Models::Description note attributes to the DataCite descriptions attributes
+      #  see https://support.datacite.org/reference/dois-2#put_dois-id
+      class Descriptions
+        # @param [Cocina::Models::Description] cocina_desc
+        # @return [NilClass, Array<Hash>] list of DataCite descriptions attributes, conforming to the expectations of
+        # HTTP PUT request to DataCite
+        def self.build(...)
+          new(...).call
+        end
+
+        def initialize(description:)
+          @description = description
+        end
+
+        # @return [NilClass, Array<Hash>] list of DataCite descriptions attributes, conforming to the expectations of
+        # HTTP PUT request to DataCite
+        def call
+          return unless abstract
+
+          [{
+            description: abstract,
+            descriptionType: 'Abstract'
+          }]
+        end
+
+        private
+
+        attr_reader :description
+
+        def abstract
+          @abstract ||= Array(description.note).find { |cocina_note| cocina_note.type == 'abstract' }&.value
+        end
+      end
+    end
+  end
+end

data/lib/datacite/mapping/from_cocina/identifiers.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Datacite
+  module Mapping
+    module FromCocina
+      # Transform the Cocina::Models::Identification to the DataCite identifier attributes
+      class Identifiers
+        # @param [Cocina::Models::Identification] identification
+        def self.build(...)
+          new(...).call
+        end
+
+        def initialize(identification:)
+          @identification = identification
+        end
+
+        attr_reader :identification
+
+        def call
+          [{
+            identifier: identification.doi,
+            identifierType: 'DOI'
+          }]
+        end
+      end
+    end
+  end
+end

data/lib/datacite/mapping/from_cocina/related_resource.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Datacite
+  module Mapping
+    module FromCocina
+      # Transform the Cocina::Models::Description relatedResource attributes to the DataCite relatedItem attributes
+      #  see https://support.datacite.org/reference/dois-2#put_dois-id
+      class RelatedResource # rubocop:disable Metrics/ClassLength
+        RELATION_TYPE_MAP = {
+          'supplement to' => 'IsSupplementTo',
+          'supplemented by' => 'IsSupplementedBy',
+          'referenced by' => 'IsReferencedBy',
+          'references' => 'References',
+          'derived from' => 'IsDerivedFrom',
+          'source of' => 'IsSourceOf',
+          'version of record' => 'IsVersionOf',
+          'identical to' => 'IsIdenticalTo',
+          'has version' => 'HasVersion',
+          'preceded by' => 'Continues',
+          'succeeded by' => 'IsContinuedBy',
+          'part of' => 'IsPartOf',
+          'has part' => 'HasPart'
+        }.freeze
+
+        # @param [Cocina::Models::RelatedResource] related_resource
+        # @return [Hash] Hash of DataCite relatedItem attributes, conforming to the expectations of HTTP PUT
+        # request to DataCite or nil if blank
+        #  see https://support.datacite.org/reference/dois-2#put_dois-id
+        def self.related_item_attributes(...)
+          new(...).related_item_attributes
+        end
+
+        # @param [Cocina::Models::RelatedResource] related_resource
+        # @return [Hash] Hash of DataCite relatedIdentifier attributes, conforming to the expectations of HTTP PUT
+        # request to DataCite or nil if blank
+        #  see https://support.datacite.org/reference/dois-2#put_dois-id
+        def self.related_identifier_attributes(...)
+          new(...).related_identifier_attributes
+        end
+
+        def initialize(related_resource:)
+          @related_resource = related_resource
+        end
+
+        # @return [Hash,nil] Array of DataCite relatedItem attributes, conforming to the expectations of HTTP PUT
+        # request to DataCite or nil if blank
+        #  see https://support.datacite.org/reference/dois-2#put_dois-id
+        def related_item_attributes # rubocop:disable Metrics/MethodLength
+          return if related_resource_blank?
+
+          titles = related_item_title ? [title: related_item_title] : []
+          id, type = unpack_related_uri_and_type
+
+          if id && type
+            {
+              relatedItemType: 'Other',
+              titles: titles,
+              relationType: relation_type,
+              relatedItemIdentifier: {
+                relatedItemIdentifier: id,
+                relatedItemIdentifierType: type
+              }
+            }
+          else
+            {
+              relatedItemType: 'Other',
+              titles: titles,
+              relationType: relation_type
+            }
+          end
+        end
+
+        # @return [Hash,nil] Array of DataCite relatedIdentifier attributes, conforming to the expectations of HTTP PUT
+        # request to DataCite or nil if blank or the identifier lacks a URI or Type
+        #  see https://support.datacite.org/reference/dois-2#put_dois-id
+        def related_identifier_attributes
+          return if related_identifier_blank?
+
+          id, type = unpack_related_uri_and_type
+          return unless id && type
+
+          {
+            resourceTypeGeneral: 'Other',
+            relationType: relation_type,
+            relatedIdentifier: id,
+            relatedIdentifierType: type
+          }
+        end
+
+        private
+
+        attr_reader :related_resource
+
+        def relation_type
+          related_resource.dataCiteRelationType || RELATION_TYPE_MAP.fetch(related_resource.type, 'References')
+        end
+
+        def related_resource_blank?
+          return true if related_resource.blank?
+
+          related_resource_hash = related_resource.to_h.slice(:note, :title, :access, :identifier)
+          related_resource_hash.blank? || related_resource_hash.each_value.all?(&:blank?)
+        end
+
+        def related_identifier_blank?
+          return true if related_resource.blank?
+
+          related_resource_hash = related_resource.to_h.slice(:access, :identifier)
+          related_resource_hash.blank? || related_resource_hash.each_value.all?(&:blank?)
+        end
+
+        def related_item_title
+          @related_item_title ||= preferred_citation || other_title \
+            || related_item_doi || related_item_arxiv || related_item_pmid \
+            || related_item_identifier_url
+        end
+
+        def preferred_citation
+          Array(related_resource.note).find do |note|
+            note.type == 'preferred citation' && note.value.present?
+          end&.value
+        end
+
+        def other_title
+          Array(related_resource.title).find do |title|
+            title.value.present?
+          end&.value
+        end
+
+        def related_item_doi
+          Array(related_resource.identifier).find do |identifier|
+            identifier.type == 'doi' && identifier.uri.present?
+          end&.uri
+        end
+
+        def related_item_arxiv
+          Array(related_resource.identifier).find do |identifier|
+            identifier.type == 'arxiv' && identifier.uri.present?
+          end&.uri
+        end
+
+        def related_item_pmid
+          Array(related_resource.identifier).find do |identifier|
+            identifier.type == 'pmid' && identifier.uri.present?
+          end&.uri
+        end
+
+        def related_item_identifier_url
+          @related_item_identifier_url ||= Array(related_resource.access&.url).find do |url|
+            url.value.present?
+          end&.value
+        end
+
+        def unpack_related_uri_and_type
+          if related_item_doi
+            [related_item_doi, 'DOI']
+          elsif related_item_arxiv
+            [related_item_arxiv, 'arXiv']
+          elsif related_item_pmid
+            [related_item_pmid, 'PMID']
+          elsif related_item_identifier_url
+            [related_item_identifier_url, 'URL']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datacite/mapping/from_cocina/rights_list.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Datacite
+  module Mapping
+    module FromCocina
+      # Transform the Cocina::Models::DROAccess attributes to the DataCite rightsList attributes
+      #  see https://support.datacite.org/reference/dois-2#put_dois-id
+      class RightsList
+        # @param [Cocina::Models::DROAccess] cocina_item_access
+        # @return [NilClass,Array<Hash>] list of DataCite rightsList attributes, conforming to the expectations of
+        # HTTP PUT request to DataCite
+        def self.build(...)
+          new(...).call
+        end
+
+        def initialize(access:)
+          @access = access
+        end
+
+        # @return [NilClass,Array<Hash>] list of DataCite rightsList attributes, conforming to the expectations of
+        # HTTP PUT request to DataCite
+        def call
+          return if access&.license.blank?
+
+          [{
+            rightsUri: access&.license
+          }]
+        end
+
+        private
+
+        attr_reader :access
+      end
+    end
+  end
+end