labimotion 2.2.0.rc13 → 2.2.0.rc14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ec9d0808468d0b4447f577e3932d0e421c248020df87eeee277a5242fc3a0e6
-  data.tar.gz: de0e10512eb0ce1e0bb72fc60983119637c869e43816aed20c0f88419a474d37
+  metadata.gz: 92bb0da102b4ac516f423c274a21bb59a08fffecb2d451d0f1d5caee8631d5af
+  data.tar.gz: e25335102afc9aa97669c3c09f671f64fa2102344fa2764817b6fe9556638359
 SHA512:
-  metadata.gz: eb60f1b75b504783636051ee83553e44b8edd71c03cf42abdfd8187405bd53ab150d5a136c7321a4a29b3a6a947aa397fba77b2ee8df180674a61f22b3c08ed5
-  data.tar.gz: 8cbad024d4e4b12275eb2fe938fcfcbf8540ab85f1d03cd6d86059ed4aa51bc5c2c555aa1c14e8a823031d74c6107f133fe302c5cea522ef901b8a1e305a97e9
+  metadata.gz: f9f574b0057178c25cb0624bd11370757adf1992e8f5734a7492ac380dadd779d06c83accabe1e59c07e189ce316258da0a8177b2c42fa028f4aaf418245fbda
+  data.tar.gz: f9d629342ffead4be91ce5728d2048a56b9de3da660df32b962d549756391ca34758edf7e1392e3aefbd117d185ff179cda085e59f4d5ad4b20e802fbdcbf060

data/lib/labimotion/apis/labimotion_doi_api.rb

@@ -6,11 +6,11 @@ module Labimotion
   class LabimotionDoiAPI < Grape::API
     # rubocop:disable Metrics/BlockLength
     # Grape route and helper DSL blocks are necessarily large.
-    KLASS_TYPES = ::Usecases::Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE.keys.freeze
+    KLASS_TYPES = Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE.keys.freeze
 
     helpers do
       def resolve_klass!(type, id)
-        model = ::Usecases::Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE[type]
+        model = Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE[type]
         error!('unknown template type', 404) unless model
 
         record = model.find_by(id: id)
@@ -20,7 +20,7 @@ module Labimotion
       end
 
       def render_template_doi(record)
-        type = ::Usecases::Labimotion::TemplateDoiHelpers.klass_type_for(record)
+        type = Labimotion::TemplateDoiHelpers.klass_type_for(record)
         dois = ::Doi.labimotion_dois(record)
         # `doi` is the current (most recently reserved) DOI; `released_doi` is the
         # latest released (minted) one. They differ once a new version has been
@@ -35,9 +35,9 @@ module Labimotion
           publication: (record.properties_template || {})['publication'],
           released_at: record.released_at,
           released_by: record.released_by,
-          new_version_available: ::Usecases::Labimotion::TemplateDoiHelpers.new_version_available?(record),
+          new_version_available: Labimotion::TemplateDoiHelpers.new_version_available?(record),
           next_doi_version: ::Doi.labimotion_version_segment(record),
-          template_url: ::Usecases::Labimotion::TemplateDoiHelpers.template_url(record)
+          template_url: Labimotion::TemplateDoiHelpers.template_url(record)
         )
       end
 
@@ -67,7 +67,7 @@ module Labimotion
           label: record.try(:label),
           template_version: record.try(:version),
           next_doi_version: ::Doi.labimotion_version_segment(record),
-          template_url: ::Usecases::Labimotion::TemplateDoiHelpers.template_url(record),
+          template_url: Labimotion::TemplateDoiHelpers.template_url(record),
           publication: publication,
           versions: versions
         )
@@ -82,7 +82,7 @@ module Labimotion
         route_param :type, type: String, values: KLASS_TYPES do
           desc 'Released DOIs + publication metadata for every released template of a type'
           get :released do
-            model = ::Usecases::Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE[params[:type]]
+            model = Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE[params[:type]]
             grouped = ::Doi.where(doiable_type: model.name).where.not(minted_at: nil)
                            .order(:id).group_by(&:doiable_id)
             records = model.where(id: grouped.keys).index_by(&:id)
@@ -98,7 +98,7 @@ module Labimotion
       route_param :type, type: String, values: KLASS_TYPES do
         desc "DOI state (reserved / released) per template of a type, for the designer grid's DOI icon"
         get :states do
-          model = ::Usecases::Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE[params[:type]]
+          model = Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE[params[:type]]
           grouped = ::Doi.where(doiable_type: model.name).order(:id).group_by(&:doiable_id)
           states = grouped.transform_values do |list|
             released = list.last.minted == true
@@ -125,7 +125,7 @@ module Labimotion
                 version: ::Doi.labimotion_doi_version(doi),
                 full_doi: doi.full_doi,
                 minted: doi.minted == true,
-                xml: ::Usecases::Labimotion::BuildTemplateDoiXml.new(record, doi, current_user).call
+                xml: Labimotion::BuildTemplateDoiXml.new(record, doi, current_user).call
               }
             end
             { versions: versions }
@@ -137,7 +137,7 @@ module Labimotion
           end
           put :publication_metadata do
             record = resolve_klass!(params[:type], params[:id])
-            uc = ::Usecases::Labimotion::UpdateTemplatePublicationMetadata.new(
+            uc = Labimotion::UpdateTemplatePublicationMetadata.new(
               record, current_user, params[:publication]
             ).call
             error!(uc.error, 422) unless uc.success?
@@ -148,7 +148,7 @@ module Labimotion
           desc 'Reserves a DataCite DOI for a template'
           post :reserve_doi do
             record = resolve_klass!(params[:type], params[:id])
-            uc = ::Usecases::Labimotion::ReserveTemplateDoi.new(record, current_user).call
+            uc = Labimotion::ReserveTemplateDoi.new(record, current_user).call
             error!(uc.error, 422) unless uc.success?
 
             render_template_doi(record.reload)
@@ -157,7 +157,7 @@ module Labimotion
           desc 'Releases (mints) the reserved DOI for a template'
           post :release_doi do
             record = resolve_klass!(params[:type], params[:id])
-            uc = ::Usecases::Labimotion::ReleaseTemplateDoi.new(record, current_user).call
+            uc = Labimotion::ReleaseTemplateDoi.new(record, current_user).call
             error!(uc.error, 422) unless uc.success?
 
             render_template_doi(record.reload)

data/lib/labimotion/apis/labimotion_template_browse_api.rb

@@ -7,7 +7,7 @@ module Labimotion
   # properties_release so the frontend can render the example inline.
   # Whitelisted in RepoAPI::PUBLIC_URLS so anonymous hub visitors can use it.
   class LabimotionTemplateBrowseAPI < Grape::API
-    KLASS_BY_TYPE = ::Usecases::Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE
+    KLASS_BY_TYPE = Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE
     KLASS_TYPES = KLASS_BY_TYPE.keys.freeze
     # type => [revision model, foreign key to the klass]
     REVISION_BY_TYPE = {
@@ -88,7 +88,7 @@ module Labimotion
           full = doi.full_doi
           { version: ::Doi.labimotion_doi_version(doi), doi: full,
             doi_url: "https://dx.doi.org/#{full}", minted_at: doi.minted_at,
-            xml: ::Usecases::Labimotion::BuildTemplateDoiXml.new(record, doi).call }
+            xml: Labimotion::BuildTemplateDoiXml.new(record, doi).call }
         end
       end
     end

data/lib/labimotion/usecases/build_template_doi_xml.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Labimotion
+  # Builds the DataCite (kernel-4) metadata XML for a LabIMotion template DOI.
+  # The same XML is uploaded to DataCite at release time and shown in the UI
+  # preview, so what users see is exactly what gets sent. A template has a
+  # single DOI; the ERB template binds to this instance, so the methods below
+  # are its accessors.
+  class BuildTemplateDoiXml
+    include ::DataCitePublisher
+
+    TEMPLATE_PATH = Rails.root.join('app/publish/datacite_metadata_labimotion_template.html.erb')
+
+    RESOURCE_LABEL = {
+      'element' => 'LabIMotion Element Template',
+      'segment' => 'LabIMotion Segment Template',
+      'dataset' => 'LabIMotion Dataset Template'
+    }.freeze
+
+    def initialize(record, doi = nil, current_user = nil)
+      @record = record
+      @doi = doi || ::Doi.labimotion_latest_doi(record)
+      @current_user = current_user
+    end
+
+    # Returns the XML string, or nil when no DOI has been reserved yet.
+    def call
+      return nil if @doi.nil?
+
+      ERB.new(File.read(TEMPLATE_PATH), trim_mode: '-').result(binding)
+    end
+
+    private
+
+    def full_doi
+      @doi.full_doi
+    end
+
+    def title
+      h(publication['title'].presence || @record.label.presence || @record.try(:name))
+    end
+
+    def description
+      h(publication['description'])
+    end
+
+    # The DOI version this DOI was reserved for (kept on the DOI), so each
+    # DOI's XML keeps showing its own version even after the template moves on.
+    def version
+      h(::Doi.labimotion_doi_version(@doi).presence || ::Doi.labimotion_version_segment(@record))
+    end
+
+    def license
+      h(publication['license'].presence || 'CC-BY-4.0')
+    end
+
+    def resource_label
+      RESOURCE_LABEL[TemplateDoiHelpers.klass_type_for(@record)]
+    end
+
+    def publication_year
+      (@doi.minted_at || Time.current).strftime('%Y')
+    end
+
+    def creators
+      Array(publication['authors']).filter_map do |author|
+        next unless author.is_a?(Hash)
+
+        given = author['givenName'].to_s.strip
+        family = author['familyName'].to_s.strip
+        next if given.empty? && family.empty?
+
+        { 'givenName' => h(given), 'familyName' => h(family),
+          'orcid' => h(author['orcid'].to_s.strip), 'affiliation' => h(author['affiliation'].to_s.strip) }
+      end
+    end
+
+    # The acting user, rendered as a DataCite "Researcher" contributor. Nil
+    # (no contributors block) when there is no user or they have no name.
+    def contributor
+      user = @current_user
+      return nil unless user
+
+      given = user.try(:first_name).to_s.strip
+      family = user.try(:last_name).to_s.strip
+      return nil if given.empty? && family.empty?
+
+      orcid = user.respond_to?(:orcid) ? user.orcid.to_s.strip : ''
+      { 'givenName' => h(given), 'familyName' => h(family), 'orcid' => h(orcid) }
+    end
+
+    def publication
+      @publication ||=
+        (@record.properties_template.is_a?(Hash) ? @record.properties_template['publication'] : nil) || {}
+    end
+
+    def h(value)
+      ERB::Util.html_escape(value.to_s)
+    end
+  end
+end

data/lib/labimotion/usecases/release_template_doi.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Mints (publishes) a previously reserved DOI for a LabIMotion template
+  # via DataCite MDS. On success flips Doi#minted=true and stamps
+  # released_by/released_at on the template record.
+  class ReleaseTemplateDoi
+    include TemplateDoiHelpers
+
+    attr_reader :record, :current_user, :doi, :error
+
+    def initialize(record, current_user)
+      @record = record
+      @current_user = current_user
+    end
+
+    def call
+      return failure('record is required') if record.nil?
+      return failure('unauthorized') unless TemplateDoiHelpers.authorized?(record, current_user)
+
+      # Release the template's current (highest-sequence) DOI — the one a fresh
+      # reserve created or returned.
+      @doi = ::Doi.labimotion_latest_doi(record)
+      return failure('doi not reserved') if @doi.nil?
+      return self if @doi.minted
+
+      return failure('publication metadata is incomplete') unless metadata_ready?
+
+      publish_at_datacite
+      self
+    end
+
+    def success?
+      @error.nil? && @doi&.minted
+    end
+
+    private
+
+    def publish_at_datacite
+      if send_to_datacite?
+        mds = ::Repo::Datacite::Mds.new
+        # DataCite requires the metadata to exist before the DOI can be minted.
+        metadata = mds.upload_metadata(BuildTemplateDoiXml.new(record, doi, current_user).call)
+        return failure(datacite_error('metadata upload', metadata)) unless metadata.is_a?(Net::HTTPSuccess)
+
+        response = mds.mint(doi.full_doi, TemplateDoiHelpers.template_url(record))
+        return failure(datacite_error('mint', response)) unless response.is_a?(Net::HTTPSuccess)
+      end
+
+      ActiveRecord::Base.transaction do
+        doi.update!(minted: true, minted_at: Time.current)
+        stamp_release_on_record
+      end
+    end
+
+    def datacite_error(step, response)
+      status = response.respond_to?(:code) ? response.code : 'unknown'
+      "datacite #{step} failed (status #{status})"
+    end
+
+    # Mirrors Publication#transition_from_doi_registering_to_registered!: only
+    # hit DataCite for real on test DOIs or in production publishing. In any
+    # other mode (e.g. dev/staging) skip the network call and just mark the
+    # DOI released locally.
+    def send_to_datacite?
+      ENV['DATACITE_MODE'] == 'test' || ENV['PUBLISH_MODE'] == 'production'
+    end
+
+    def stamp_release_on_record
+      attrs = {}
+      attrs[:released_at] = Time.current if record.respond_to?(:released_at)
+      attrs[:released_by] = current_user.id if record.respond_to?(:released_by) && current_user
+      record.update!(attrs) if attrs.any?
+    end
+
+    def metadata_ready?
+      publication = record.properties_template.is_a?(Hash) ? record.properties_template['publication'] : nil
+      return false unless publication.is_a?(Hash)
+
+      publication['title'].to_s.strip.present? &&
+        publication['description'].to_s.strip.present? &&
+        Array(publication['authors']).any? { |a| a.is_a?(Hash) && a['familyName'].to_s.strip.present? }
+    end
+
+    def failure(message)
+      @error = message
+      self
+    end
+  end
+end

data/lib/labimotion/usecases/reserve_template_doi.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Reserves a DataCite DOI for a LabIMotion template (ElementKlass /
+  # SegmentKlass / DatasetKlass). A DOI is published per major release
+  # (template X.0 -> DOI vX; later minor revisions X.y roll into v(X+1));
+  # sub-1.0 and unversioned templates map to the first DOI (v1). The existing
+  # DOI is returned unless the latest one has been released AND the template
+  # has since moved to a version that maps to a new DOI version.
+  class ReserveTemplateDoi
+    include TemplateDoiHelpers
+
+    attr_reader :record, :current_user, :doi, :error
+
+    def initialize(record, current_user)
+      @record = record
+      @current_user = current_user
+    end
+
+    def call
+      return failure('record is required') if record.nil?
+      return failure('unauthorized') unless TemplateDoiHelpers.authorized?(record, current_user)
+
+      @doi = reserve
+      self
+    end
+
+    def success?
+      @error.nil? && @doi.present?
+    end
+
+    private
+
+    # Returns the template's current DOI, or reserves one for a new version.
+    # A new DOI is only created when there is none yet, or once the latest DOI
+    # has been released and the template has moved to a new version. Otherwise
+    # the existing DOI is returned, so repeated reserves are idempotent and a
+    # released version stays read-only until the template is revised.
+    def reserve
+      latest = ::Doi.labimotion_latest_doi(record)
+      return latest if latest && !TemplateDoiHelpers.new_version_available?(record)
+
+      create_doi
+    end
+
+    def create_doi
+      suffix = ::Doi.build_labimotion_suffix(record)
+      return failure('could not build a DOI suffix for this template') if suffix.blank?
+
+      # Set inchikey == suffix and version_count: 0 so Doi#align_suffix keeps
+      # the deterministic suffix verbatim (no /concept, no rebuild).
+      ::Doi.create!(
+        doiable_id: record.id,
+        doiable_type: record.class.name,
+        inchikey: suffix,
+        suffix: suffix,
+        version_count: 0,
+        metadata: ::Doi.labimotion_doi_metadata(record)
+      )
+    rescue ActiveRecord::RecordInvalid => e
+      failure(e.message)
+      nil
+    end
+
+    def failure(message)
+      @error = message
+      self
+    end
+  end
+end

data/lib/labimotion/usecases/template_doi_helpers.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Shared helpers for LabIMotion template DOIs: the type <-> klass mapping,
+  # authorization, the public Template Hub URL and "is a new version reservable"
+  # check. Used by the template DOI usecases and APIs.
+  module TemplateDoiHelpers
+    KLASS_BY_TYPE = {
+      'element' => ::Labimotion::ElementKlass,
+      'segment' => ::Labimotion::SegmentKlass,
+      'dataset' => ::Labimotion::DatasetKlass
+    }.freeze
+
+    # Maps a template record to the `generic_admin` profile key that grants
+    # admin rights over it. Keys are plural, matching the LabIMotion gem's
+    # `authenticate_admin!` and `User#generic_admin`.
+    GENERIC_ADMIN_KEY = {
+      ::Labimotion::ElementKlass => 'elements',
+      ::Labimotion::SegmentKlass => 'segments',
+      ::Labimotion::DatasetKlass => 'datasets'
+    }.freeze
+
+    module_function
+
+    # True once the template's latest DOI has been released (minted) and the
+    # template has since moved to a new major version — i.e. a DOI for the new
+    # version may now be reserved. False while there is no DOI, the latest is
+    # still unreleased, or the DOI version is unchanged (released = read-only,
+    # and minor template revisions keep the same DOI).
+    def new_version_available?(record)
+      latest = ::Doi.labimotion_latest_doi(record)
+      return false unless latest&.minted
+
+      ::Doi.labimotion_doi_version(latest) != ::Doi.labimotion_version_segment(record)
+    end
+
+    def klass_type_for(record)
+      case record
+      when ::Labimotion::ElementKlass then 'element'
+      when ::Labimotion::SegmentKlass then 'segment'
+      when ::Labimotion::DatasetKlass then 'dataset'
+      end
+    end
+
+    # Public URL that opens the template in the LabIMotion Template Hub's
+    # "Find a Template" page (the Finder), preselecting the template type, the
+    # template and its release version:
+    #   /home/genericHub?type=finder&kind=<type>&id=<identifier|uuid>&version=<v>
+    # Used as the DOI's DataCite landing page and surfaced in the UI.
+    def template_url(record)
+      type = klass_type_for(record)
+      host = ENV['REPO_HOST'].presence || ENV['DOI_DOMAIN_TEST'].presence ||
+             ENV['DOI_DOMAIN'].presence || 'https://www.chemotion-repository.net'
+      record_id = record.try(:identifier).presence || record.try(:uuid).presence || record.id
+      query = "type=finder&kind=#{type}&id=#{record_id}"
+      version = record.try(:version)
+      query += "&version=#{version}" if version.present?
+      "#{host.chomp('/')}/home/genericHub?#{query}"
+    end
+
+    # A user may manage a template's DOI iff they hold the LabIMotion
+    # `generic_admin` right for that template kind — the same gate the gem's
+    # `authenticate_admin!` and the admin UI use. `admin_ids`/`created_by` do
+    # NOT apply: segment templates carry neither, so they were always denied.
+    def authorized?(record, user)
+      return false unless record && user
+
+      key = GENERIC_ADMIN_KEY[record.class]
+      return false unless key
+
+      admin = user.respond_to?(:generic_admin) ? user.generic_admin : nil
+      admin.is_a?(Hash) && !!admin[key]
+    end
+  end
+end

data/lib/labimotion/usecases/update_template_publication_metadata.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Merges a normalized "publication" sub-object into the template's
+  # properties_template jsonb. Keeps the rest of the jsonb untouched so the
+  # labimotion gem's runtime shape stays intact.
+  class UpdateTemplatePublicationMetadata
+    include TemplateDoiHelpers
+
+    ALLOWED_KEYS = %w[title description authors license].freeze
+
+    attr_reader :record, :current_user, :publication, :error
+
+    def initialize(record, current_user, publication)
+      @record = record
+      @current_user = current_user
+      @publication = publication
+    end
+
+    def call
+      return failure('record is required') if record.nil?
+      return failure('unauthorized') unless TemplateDoiHelpers.authorized?(record, current_user)
+      return failure('publication payload must be a hash') unless publication.is_a?(Hash)
+
+      merged = normalized_publication
+      props = (record.properties_template || {}).dup
+      props['publication'] = merged
+      record.update!(properties_template: props)
+      @publication = merged
+      self
+    end
+
+    def success?
+      @error.nil?
+    end
+
+    private
+
+    def normalized_publication
+      slice = publication.stringify_keys.slice(*ALLOWED_KEYS)
+      slice['authors'] = Array(slice['authors']).filter_map { |a| normalize_author(a) }
+      slice
+    end
+
+    def normalize_author(author)
+      return nil unless author.is_a?(Hash)
+
+      h = author.stringify_keys.slice('givenName', 'familyName', 'orcid', 'affiliation', 'affiliation_id')
+      return nil if h.values_at('givenName', 'familyName').all? { |v| v.to_s.strip.empty? }
+
+      h
+    end
+
+    def failure(message)
+      @error = message
+      self
+    end
+  end
+end

data/lib/labimotion/version.rb

@@ -2,5 +2,5 @@
 
 ## Labimotion Version
 module Labimotion
-  VERSION = '2.2.0.rc13'
+  VERSION = '2.2.0.rc14'
 end

data/lib/labimotion.rb

@@ -71,6 +71,13 @@ module Labimotion
   autoload :RepositoryHelpers, 'labimotion/helpers/repository_helpers'
   autoload :VocabularyHelpers, 'labimotion/helpers/vocabulary_helpers'
 
+  ######## Usecases
+  autoload :TemplateDoiHelpers, 'labimotion/usecases/template_doi_helpers'
+  autoload :BuildTemplateDoiXml, 'labimotion/usecases/build_template_doi_xml'
+  autoload :ReserveTemplateDoi, 'labimotion/usecases/reserve_template_doi'
+  autoload :ReleaseTemplateDoi, 'labimotion/usecases/release_template_doi'
+  autoload :UpdateTemplatePublicationMetadata, 'labimotion/usecases/update_template_publication_metadata'
+
   ######## Libs
   autoload :Converter, 'labimotion/libs/converter'
   autoload :DatasetBuilder, 'labimotion/libs/dataset_builder'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.2.0.rc13
+  version: 2.2.0.rc14
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -164,6 +164,11 @@ files:
 - lib/labimotion/models/template_submission.rb
 - lib/labimotion/models/vocabulary.rb
 - lib/labimotion/models/wellplate.rb
+- lib/labimotion/usecases/build_template_doi_xml.rb
+- lib/labimotion/usecases/release_template_doi.rb
+- lib/labimotion/usecases/reserve_template_doi.rb
+- lib/labimotion/usecases/template_doi_helpers.rb
+- lib/labimotion/usecases/update_template_publication_metadata.rb
 - lib/labimotion/utils/con_state.rb
 - lib/labimotion/utils/export_utils.rb
 - lib/labimotion/utils/field_type.rb