datacite 0.7.0 → 0.8.0

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

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Datacite
+  module Mapping
+    module FromCocina
+      # Transform the Cocina::Models::Description subjects attributes to the DataCite subjects attributes
+      #  see https://support.datacite.org/reference/dois-2#put_dois-id
+      class Subject
+        # @param [Cocina::Models::Description] description
+        # @return [NilClass,Array<Hash>] list of DataCite subjects 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 subjects attributes, conforming to the expectations of
+        # HTTP PUT request to DataCite
+        def call
+          return if description&.subject.blank?
+
+          results = description.subject.map do |cocina_subject|
+            subject(cocina_subject)
+          end
+          results.compact.presence
+        end
+
+        private
+
+        attr_reader :description
+
+        def subject(cocina_subject)
+          return if cocina_subject.blank?
+
+          if fast?(cocina_subject)
+            fast_subject(cocina_subject)
+          else
+            non_fast_subject(cocina_subject)
+          end
+        end
+
+        def fast_subject(cocina_subject)
+          {
+            subjectScheme: 'fast',
+            schemeUri: 'http://id.worldcat.org/fast/'
+
+          }.tap do |attribs|
+            attribs[:subject] = cocina_subject.value if cocina_subject.value.present?
+            attribs[:valueUri] = cocina_subject.uri if cocina_subject.uri.present?
+          end
+        end
+
+        def non_fast_subject(cocina_subject)
+          return if cocina_subject.value.blank?
+
+          { subject: cocina_subject.value }
+        end
+
+        def fast?(cocina_subject)
+          cocina_subject&.source&.code == 'fast'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Datacite
+  module Mapping
+    module FromCocina
+      # Transform the Cocina::Models::Description title attributes to attributes for one DataCite title
+      #  see https://support.datacite.org/reference/dois-2#put_dois-id
+      class Titles
+        # @param [Cocina::Models::Description] description
+        # @return [Array<Hash>] list of titles for DataCite, conforming to the expectations of HTTP PUT request
+        # to DataCite
+        def self.build(...)
+          new(...).call
+        end
+
+        def initialize(description:)
+          @description = description
+        end
+
+        # @return [Array<Hash>] list of titles for DataCite, conforming to the expectations of HTTP PUT request
+        # to DataCite
+        def call
+          [{ title: description.title.first.value }]
+        end
+
+        private
+
+        attr_reader :description
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Datacite
+  module Mapping
+    module FromCocina
+      # Transform the Cocina::Models::Description form attributes to the DataCite types attributes
+      #  see https://support.datacite.org/reference/dois-2#put_dois-id
+      class Types
+        # @param [Cocina::Models::Description] description
+        # @return [NilClass, Hash] the DataCite types 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, Hash] the DataCite types attributes, conforming to the expectations of HTTP PUT request
+        # to DataCite
+        def call
+          return unless resource_type_general || resource_type
+
+          {
+            resourceTypeGeneral: resource_type_general,
+            resourceType: resource_type || ''
+          }
+        end
+
+        private
+
+        attr_reader :description
+
+        # @return String DataCite resourceTypeGeneral value
+        def resource_type_general
+          @resource_type_general ||= Array(description.form).find do |cocina_form|
+            datacite_resource_types_form?(cocina_form)
+          end&.value
+        end
+
+        # @return [String] DataCite resourceType value
+        def resource_type
+          @resource_type ||= begin
+            self_deposit_form = Array(description.form).find { |cocina_form| self_deposit_form?(cocina_form) }
+
+            subtypes = self_deposit_subtypes(self_deposit_form)
+            if subtypes.blank?
+              self_deposit_type(self_deposit_form)
+            else
+              subtypes.select { |subtype| subtype if subtype != resource_type_general }.join('; ')
+            end
+          end
+        end
+
+        # call with cocina form element for Stanford self deposit resource types
+        # @return String the value from the structuredValue when the type is 'type' for the cocina form element
+        def self_deposit_type(cocina_self_deposit_form)
+          cocina_self_deposit_form&.structuredValue&.each do |struct_val|
+            return struct_val.value if struct_val.type == 'type'
+          end
+        end
+
+        def self_deposit_subtypes(cocina_self_deposit_form)
+          cocina_self_deposit_form&.structuredValue&.filter_map do |struct_val|
+            struct_val.value if struct_val.type == 'subtype'
+          end
+        end
+
+        def self_deposit_form?(cocina_form)
+          cocina_form.type == 'resource type' &&
+            cocina_form.source&.value == 'Stanford self-deposit resource types'
+        end
+
+        def datacite_resource_types_form?(cocina_form)
+          cocina_form.source&.value == 'DataCite resource types'
+        end
+      end
+    end
+  end
+end