hyrax-doi 0.1.0

data/app/models/concerns/hyrax/doi/solr_document/datacite_doi_behavior.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Hyrax
+  module DOI
+    module SolrDocument
+      module DataCiteDOIBehavior
+        extend ActiveSupport::Concern
+
+        included do
+          attribute :doi_status_when_public, ::SolrDocument::Solr::String, "doi_status_when_public_ssi"
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/hyrax/doi/solr_document/doi_behavior.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Hyrax
+  module DOI
+    module SolrDocument
+      module DOIBehavior
+        extend ActiveSupport::Concern
+
+        included do
+          attribute :doi, ::SolrDocument::Solr::String, "doi_ssi"
+        end
+      end
+    end
+  end
+end

data/app/presenters/concerns/hyrax/doi/datacite_doi_presenter_behavior.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module Hyrax
+  module DOI
+    module DataCiteDOIPresenterBehavior
+      extend ActiveSupport::Concern
+
+      delegate :doi_status_when_public, to: :solr_document
+
+      # Should this make a request to DataCite?
+      # Or maybe DataCite could supply badges?
+      def doi_status
+        if doi_status_when_public == 'findable' && !solr_document.public?
+          'registered'
+        else
+          doi_status_when_public
+        end
+      end
+    end
+  end
+end

data/app/presenters/concerns/hyrax/doi/doi_presenter_behavior.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Hyrax
+  module DOI
+    module DOIPresenterBehavior
+      extend ActiveSupport::Concern
+
+      def doi
+        solr_document.doi.present? ? "https://doi.org/#{solr_document.doi}" : nil
+      end
+    end
+  end
+end

data/app/services/bolognese/readers/hyrax_work_reader.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+require 'bolognese'
+
+module Bolognese
+  module Readers
+    # Use this with Bolognese like the following:
+    # m = Bolognese::Metadata.new(input: work.attributes.merge(has_model: work.has_model.first).to_json, from: 'hyrax_work')
+    # Then crosswalk it with:
+    # m.datacite
+    # Or:
+    # m.ris
+    module HyraxWorkReader
+      # Not usable right now given how Metadata#initialize works
+      # def get_hyrax_work(id: nil, **options)
+      #   work = ActiveFedora::Base.find(id)
+      #   { "string" => work.attributes.merge(has_model: work.has_model).to_json }
+      # end
+
+      def read_hyrax_work(string: nil, **options)
+        read_options = ActiveSupport::HashWithIndifferentAccess.new(options.except(:doi, :id, :url, :sandbox, :validate, :ra))
+
+        meta = string.present? ? Maremma.from_json(string) : {}
+
+        {
+          # "id" => meta.fetch('id', nil),
+          "identifiers" => read_hyrax_work_identifiers(meta),
+          "types" => read_hyrax_work_types(meta),
+          "doi" => normalize_doi(meta.fetch('doi', nil)&.first),
+          # "url" => normalize_id(meta.fetch("URL", nil)),
+          "titles" => read_hyrax_work_titles(meta),
+          "creators" => read_hyrax_work_creators(meta),
+          "contributors" => read_hyrax_work_contributors(meta),
+          # "container" => container,
+          "publisher" => read_hyrax_work_publisher(meta),
+          # "related_identifiers" => related_identifiers,
+          # "dates" => dates,
+          "publication_year" => read_hyrax_work_publication_year(meta),
+          "descriptions" => read_hyrax_work_descriptions(meta),
+          # "rights_list" => rights_list,
+          # "version_info" => meta.fetch("version", nil),
+          "subjects" => read_hyrax_work_subjects(meta)
+          # "state" => state
+        }.merge(read_options)
+      end
+
+      private
+
+      def read_hyrax_work_types(meta)
+        # TODO: Map work.resource_type or work.
+        resource_type_general = "Other"
+        hyrax_resource_type = meta.fetch('has_model', nil) || "Work"
+        resource_type = meta.fetch('resource_type', nil).presence || hyrax_resource_type
+        {
+          "resourceTypeGeneral" => resource_type_general,
+          "resourceType" => resource_type,
+          "hyrax" => hyrax_resource_type
+        }.compact
+      end
+
+      def read_hyrax_work_creators(meta)
+        get_authors(Array.wrap(meta.fetch("creator", nil))) if meta.fetch("creator", nil).present?
+      end
+
+      def read_hyrax_work_contributors(meta)
+        get_authors(Array.wrap(meta.fetch("contributor", nil))) if meta.fetch("contributor", nil).present?
+      end
+
+      def read_hyrax_work_titles(meta)
+        Array.wrap(meta.fetch("title", nil)).select(&:present?).collect { |r| { "title" => sanitize(r) } }
+      end
+
+      def read_hyrax_work_descriptions(meta)
+        Array.wrap(meta.fetch("description", nil)).select(&:present?).collect { |r| { "description" => sanitize(r) } }
+      end
+
+      def read_hyrax_work_publication_year(meta)
+        # FIXME: better parsing of free text dates...maybe using EDTF?
+        date = meta.fetch("date_created", nil)&.first
+        date ||= meta.fetch("date_uploaded", nil)
+        Date.parse(date.to_s).year
+      rescue Date::Error
+        Time.zone.today.year
+      end
+
+      def read_hyrax_work_subjects(meta)
+        Array.wrap(meta.fetch("keyword", nil)).select(&:present?).collect { |r| { "subject" => sanitize(r) } }
+      end
+
+      def read_hyrax_work_identifiers(meta)
+        Array.wrap(meta.fetch("identifier", nil)).select(&:present?).collect { |r| { "identifier" => sanitize(r) } }
+      end
+
+      def read_hyrax_work_publisher(meta)
+        # Fallback to ':unav' since this is a required field for datacite
+        parse_attributes(meta.fetch("publisher")).to_s.strip.presence || ":unav"
+      end
+    end
+  end
+end

data/app/services/bolognese/writers/hyrax_work_writer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require 'bolognese'
+
+module Bolognese
+  module Writers
+    # Use this with Bolognese like the following:
+    # m = Bolognese::Metadata.new(input: '10.18130/v3-k4an-w022')
+    # Then crosswalk it with:
+    # m.hyrax_work
+    module HyraxWorkWriter
+      def hyrax_work
+        attributes = {
+          'identifier' => Array(identifiers).select { |id| id["identifierType"] != "DOI" }.pluck("identifier"),
+          'doi' => build_hyrax_work_doi,
+          'title' => titles&.pluck("title"),
+          # FIXME: This may not roundtrip since datacite normalizes the creator name
+          'creator' => creators&.pluck("name"),
+          'contributor' => contributors&.pluck("name"),
+          'publisher' => Array(publisher),
+          'date_created' => Array(publication_year),
+          'description' => descriptions&.pluck("description"),
+          'keyword' => subjects&.pluck("subject")
+        }
+        hyrax_work_class = determine_hyrax_work_class
+        # Only pass attributes that the work type knows about
+        hyrax_work_class.new(attributes.slice(*hyrax_work_class.attribute_names))
+      end
+
+      private
+
+      def determine_hyrax_work_class
+        # Need to check that the class `responds_to? :doi`?
+        types["hyrax"]&.safe_constantize || build_hyrax_work_class
+      end
+
+      def build_hyrax_work_class
+        Class.new(ActiveFedora::Base).tap do |c|
+          c.include ::Hyrax::WorkBehavior
+          c.include ::Hyrax::DOI::DOIBehavior
+          # Put BasicMetadata include last since it finalizes the metadata schema
+          c.include ::Hyrax::BasicMetadata
+        end
+      end
+
+      def build_hyrax_work_doi
+        Array(doi&.sub('https://doi.org/', ''))
+      end
+    end
+  end
+end

data/app/services/hyrax/doi/datacite_client.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+module Hyrax
+  module DOI
+    class DataCiteClient
+      attr_reader :username, :password, :prefix, :mode
+
+      TEST_BASE_URL = "https://api.test.datacite.org/"
+      TEST_MDS_BASE_URL = "https://mds.test.datacite.org/"
+      PRODUCTION_BASE_URL = "https://api.datacite.org"
+      PRODUCTION_MDS_BASE_URL = "https://mds.datacite.org/"
+
+      def initialize(username:, password:, prefix:, mode: :production)
+        @username = username
+        @password = password
+        @prefix = prefix
+        @mode = mode
+      end
+
+      # Mint a draft DOI without metadata or a url
+      # If you already have a DOI and want to register it as a draft then go through the normal process (put_metadata/register_url)
+      def create_draft_doi
+        # Use regular api instead of mds for metadata-less url-less draft doi creation
+        response = connection.post('dois', draft_doi_payload.to_json, "Content-Type" => "application/json")
+        raise Error.new('Failed creating draft DOI', response) unless response.status == 201
+
+        JSON.parse(response.body)['data']['id']
+      end
+
+      def delete_draft_doi(doi)
+        response = mds_connection.delete("doi/#{doi}")
+        raise Error.new('Failed deleting draft DOI', response) unless response.status == 200
+
+        doi
+      end
+
+      def get_metadata(doi)
+        response = mds_connection.get("metadata/#{doi}")
+        raise Error.new('Failed getting DOI metadata', response) unless response.status == 200
+
+        Nokogiri::XML(response.body).remove_namespaces!
+      end
+
+      # This will mint a new draft DOI if the passed doi parameter is blank
+      # The passed datacite xml needs an identifier (just the prefix when minting new DOIs)
+      # Beware: This will convert registered DOIs into findable!
+      def put_metadata(doi, metadata)
+        doi = prefix if doi.blank?
+        response = mds_connection.put("metadata/#{doi}", metadata, { 'Content-Type': 'application/xml;charset=UTF-8' })
+        raise Error.new('Failed creating metadata for DOI', response) unless response.status == 201
+
+        /^OK \((?<found_or_created_doi>.*)\)$/ =~ response.body
+        found_or_created_doi
+      end
+
+      # Beware: This will make findable DOIs become registered (by setting is_active to false)
+      # Otherwise this has no effect on the DOI's metadata (even when draft)
+      # Beware: Attempts to delete the metadata of an unknown DOI will actually create a blank draft DOI
+      def delete_metadata(doi)
+        response = mds_connection.delete("metadata/#{doi}")
+        raise Error.new('Failed deleting DOI metadata', response) unless response.status == 200
+
+        doi
+      end
+
+      def get_url(doi)
+        response = mds_connection.get("doi/#{doi}")
+        raise Error.new('Failed getting DOI url', response) unless response.status == 200
+
+        response.body
+      end
+
+      # Beware: This will convert draft DOIs to findable!
+      # Metadata needs to be registered for a DOI before a url can be registered
+      def register_url(doi, url)
+        payload = "doi=#{doi}\nurl=#{url}"
+        response = mds_connection.put("doi/#{doi}", payload, { 'Content-Type': 'text/plain;charset=UTF-8' })
+        raise Error.new('Failed registering url for DOI', response) unless response.status == 201
+
+        url
+      end
+
+      class Error < RuntimeError
+        ##
+        # @!attribute [r] status
+        #   @return [Integer]
+        attr_reader :status
+
+        ##
+        # @param msg      [String]
+        # @param response [Faraday::Response]
+        def initialize(msg = '', response = nil)
+          if response
+            @status = response.status
+            msg += "\n#{@status}: #{response.reason_phrase}\n"
+            msg += response.body
+          end
+
+          super(msg)
+        end
+      end
+
+      private
+
+      def connection
+        Faraday.new(url: base_url) do |c|
+          c.basic_auth(username, password)
+          c.adapter(Faraday.default_adapter)
+        end
+      end
+
+      def mds_connection
+        Faraday.new(url: mds_base_url) do |c|
+          c.basic_auth(username, password)
+          c.adapter(Faraday.default_adapter)
+        end
+      end
+
+      def draft_doi_payload
+        {
+          "data": {
+            "type": "dois",
+            "attributes": {
+              "prefix": prefix
+            }
+          }
+        }
+      end
+
+      def base_url
+        mode == :production ? PRODUCTION_BASE_URL : TEST_BASE_URL
+      end
+
+      def mds_base_url
+        mode == :production ? PRODUCTION_MDS_BASE_URL : TEST_MDS_BASE_URL
+      end
+    end
+  end
+end

data/app/services/hyrax/doi/datacite_registrar.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+module Hyrax
+  module DOI
+    class DataCiteRegistrar < Hyrax::Identifier::Registrar
+      STATES = %w[draft registered findable].freeze
+
+      # FIXME: make this configurable in a different way so tenants can have different configs in Hyku
+      class_attribute :prefix, :username, :password, :mode
+
+      def initialize(builder: Hyrax::Identifier::Builder.new(prefix: self.prefix))
+        super
+      end
+
+      ##
+      # @param object [#id]
+      #
+      # @return [#identifier]
+      def register!(object: work)
+        doi = Array(object.try(:doi)).first
+
+        # Return the existing DOI or nil if nothing needs to be done
+        return Struct.new(:identifier).new(doi) unless register?(object)
+
+        # Create a draft DOI (if necessary)
+        doi ||= mint_draft_doi
+
+        # Submit metadata, register url, and ensure proper status
+        submit_to_datacite(object, doi)
+
+        # Return the doi (old or new)
+        Struct.new(:identifier).new(doi)
+      end
+
+      def mint_draft_doi
+        client.create_draft_doi
+      end
+
+      private
+
+      # Should the work be submitted for registration (or updating)?
+      # @return [boolean]
+      def register?(work)
+        doi_enabled_work_type?(work) &&
+          doi_minting_enabled? &&
+          work.doi_status_when_public.in?(Hyrax::DOI::DataCiteRegistrar::STATES)
+        # TODO: add more checks here to catch cases when updating is unnecessary
+        # TODO: check that required metadata is present if set to registered or findable
+      end
+
+      # Check if work is DOI enabled
+      def doi_enabled_work_type?(work)
+        work.class.ancestors.include?(Hyrax::DOI::DOIBehavior) && work.class.ancestors.include?(Hyrax::DOI::DataCiteDOIBehavior)
+      end
+
+      def doi_minting_enabled?
+        # TODO: Check feature flipper (needs to be per work type? per tenant for Hyku?)
+        true
+      end
+
+      def public?(work)
+        work.visibility == Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+      end
+
+      def client
+        @client ||= Hyrax::DOI::DataCiteClient.new(username: self.username, password: self.password, prefix: self.prefix, mode: mode)
+      end
+
+      # Do the heavy lifting of submitting the metadata, registering the url, and ensuring the correct status
+      def submit_to_datacite(work, doi)
+        # 1. Add metadata to the DOI (or update it)
+        # TODO: check that required metadata is present if current DOI record is registered or findable OR handle error?
+        client.put_metadata(doi, work_to_datacite_xml(work))
+
+        # 2. Register a url with the DOI if it should be registered or findable
+        client.register_url(doi, work_url(work)) if work.doi_status_when_public.in?(['registered', 'findable'])
+
+        # 3. Always call delete metadata unless findable and public
+        # Do this because it has no real effect on the metadata and
+        # the put_metadata or register_url above may have made it findable.
+        client.delete_metadata(doi) unless work.doi_status_when_public == 'findable' && public?(work)
+      end
+
+      # NOTE: default_url_options[:host] must be set for this method to work
+      def work_url(work)
+        Rails.application.routes.url_helpers.polymorphic_url(work)
+      end
+
+      def work_to_datacite_xml(work)
+        Bolognese::Metadata.new(input: work.attributes.merge(has_model: work.has_model.first).to_json, from: 'hyrax_work').datacite
+      end
+
+      ## Unused methods for now but may be brought in later when filling in TODOs
+
+      # Fetch the DOI information from DataCite
+      # def datacite_record(work)
+      #   # TODO: Add some level of caching (could be memoization)
+      #   # TODO: Add error handling?
+      #   Bolognese::Metadata(input: Array(work.doi).first)
+      # end
+
+      # # Check if metadata sent to the registrar has changed
+      # def metadata_changed?(work)
+      #   fields_to_watch = %w[title creator publisher resource_type identifier description]
+      #   diff_work = datacite_record.hyrax_work
+      #   diff_work.update_attributes(work.attributes.slice(**fields_to_watch))
+      #   diff_work.changes.keys.any? { |k| k.in? fields_to_watch }
+      # end
+
+      # # Check if the status in datacite matches the expected status
+      # # except when work is not public and doi_status_when_public is findable
+      # def status_needs_updating?(work)
+      #   current_status = datacite_record.status
+      #   expected_status = work.doi_status_when_public
+      #
+      #   return false if expected_status == :findable && current_status == :registered && !is_public?(work)
+      #
+      #   current_status != expected_status
+      # end
+    end
+  end
+end