labimotion 2.2.0.rc10 → 2.2.0.rc11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 727f612dabb886b6189d747d61c391b6ccae83ebd2279a3961d38b652449b7e8
-  data.tar.gz: 9d94f4337c5d28f44cba194e45bac135a715a0d193254f5792049b688801d734
+  metadata.gz: 491f3e3075c83954b5e49caeb8b091d1aba68ddf0135fe82ddbaf6aeb4b244e9
+  data.tar.gz: ae5dc4a93ecb31559feff1060f8fb449aa3e618f86890ea25324410226f4d166
 SHA512:
-  metadata.gz: 64a75edfdc0efee53dca7bf8c03aa2747fc9cf0672723056e97a80989ca23ed03fb32700af3f38d6ebd80d757398250868bfdceb9458288ea77e4e78d79b8e8a
-  data.tar.gz: 1e594266697dd026612ba27d6f7df1566f7f8dc696c8d18ce318a35ccdfc9eaf3c6b0e0467daf9e0601253f0bcc4d78c5bbb7a624319300b6b9a091db1f6de06
+  metadata.gz: ce1f326748ee1ae7c9a71f97f43b2eef7d3273c28c9d7d7d3e87516cfcef58002927563dedbaad66ca87f6c396fd462cab6f827eb95d052cdf4f2703bfe8e307
+  data.tar.gz: 958083e170c64e0c378b38ecf9996343a88dfa6756617d0a7d6d9e548d3dbefc3b53c00eda2ec8412fd6da59ca3b959b7d0fa20f67e32a559fa74da9d01e695b

data/lib/labimotion/apis/labimotion_api.rb

@@ -16,5 +16,7 @@ module Labimotion
     mount Labimotion::MttAPI
     mount Labimotion::DoseRespRequestAPI
     mount Labimotion::ElementVariationAPI
+    mount Labimotion::LabimotionDoiAPI
+    mount Labimotion::LabimotionTemplateBrowseAPI
   end
 end

data/lib/labimotion/apis/labimotion_doi_api.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # DOI lifecycle (reserve + release) and publication metadata for
+  # LabIMotion templates: ElementKlass / SegmentKlass / DatasetKlass.
+  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
+
+    helpers do
+      def resolve_klass!(type, id)
+        model = ::Usecases::Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE[type]
+        error!('unknown template type', 404) unless model
+
+        record = model.find_by(id: id)
+        error!('template not found', 404) unless record
+
+        record
+      end
+
+      def render_template_doi(record)
+        type = ::Usecases::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
+        # reserved on top of a released one, so the modal can show both at once.
+        doi = dois.last
+        released_doi = dois.reverse.find(&:minted)
+        Labimotion::LabimotionTemplateDoiEntity.represent(
+          type: type,
+          klass_id: record.id,
+          doi: doi,
+          released_doi_version: released_doi && ::Doi.labimotion_doi_version(released_doi),
+          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),
+          next_doi_version: ::Doi.labimotion_version_segment(record),
+          template_url: ::Usecases::Labimotion::TemplateDoiHelpers.template_url(record)
+        )
+      end
+
+      # Public, read-only view of one released DOI version.
+      def released_doi_version(doi)
+        full = doi.full_doi
+        {
+          doi: full,
+          doi_url: "https://dx.doi.org/#{full}",
+          version: ::Doi.labimotion_doi_version(doi),
+          minted_at: doi.minted_at
+        }
+      end
+
+      # Public payload for a template that has at least one released DOI: the
+      # latest released DOI promoted to the top level, plus its publication
+      # metadata, hub deep-link and every released version. `record_id` matches
+      # the hub grid's row id (identifier || uuid) so the frontend can merge it.
+      def released_template_doi(record, dois)
+        versions = dois.sort_by(&:id).map { |doi| released_doi_version(doi) }
+        publication = (record.properties_template || {})['publication']
+        publication = publication.is_a?(Hash) ? publication.slice('title', 'description', 'authors', 'license') : {}
+        versions.last.merge(
+          record_id: record.try(:identifier).presence || record.try(:uuid).presence || record.id,
+          identifier: record.try(:identifier),
+          uuid: record.try(:uuid),
+          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),
+          publication: publication,
+          versions: versions
+        )
+      end
+    end
+
+    namespace :labimotion_doi do
+      # Public, anonymous read-only DOI info for the LabIMotion Template Hub.
+      # Whitelisted in RepoAPI::PUBLIC_URLS so it bypasses authenticate!; only
+      # released (minted) DOIs and their public publication metadata are exposed.
+      namespace :public do
+        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]]
+            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)
+            released = grouped.filter_map do |klass_id, dois|
+              record = records[klass_id]
+              record && released_template_doi(record, dois)
+            end
+            { released_dois: released }
+          end
+        end
+      end
+
+      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]]
+          grouped = ::Doi.where(doiable_type: model.name).order(:id).group_by(&:doiable_id)
+          states = grouped.transform_values do |list|
+            released = list.last.minted == true
+            { reserved: !released, released: released }
+          end
+          { states: states }
+        end
+
+        route_param :id, type: Integer do
+          desc 'Returns the current DOI/publication state for a template'
+          get do
+            record = resolve_klass!(params[:type], params[:id])
+            render_template_doi(record)
+          end
+
+          desc "Returns the DataCite metadata XML for every one of the template's DOI versions"
+          get :metadata_xml do
+            record = resolve_klass!(params[:type], params[:id])
+            dois = ::Doi.labimotion_dois(record)
+            error!('no DOI reserved', 404) if dois.empty?
+
+            versions = dois.map do |doi|
+              {
+                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
+              }
+            end
+            { versions: versions }
+          end
+
+          desc 'Updates the publication metadata of a template'
+          params do
+            requires :publication, type: Hash
+          end
+          put :publication_metadata do
+            record = resolve_klass!(params[:type], params[:id])
+            uc = ::Usecases::Labimotion::UpdateTemplatePublicationMetadata.new(
+              record, current_user, params[:publication]
+            ).call
+            error!(uc.error, 422) unless uc.success?
+
+            render_template_doi(record.reload)
+          end
+
+          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
+            error!(uc.error, 422) unless uc.success?
+
+            render_template_doi(record.reload)
+          end
+
+          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
+            error!(uc.error, 422) unless uc.success?
+
+            render_template_doi(record.reload)
+          end
+        end
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end

data/lib/labimotion/apis/labimotion_template_browse_api.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Public, read-only browsing of released LabIMotion templates for the Template
+  # Hub "Find a Template" tab: pick a type, a template, then a release version.
+  # Returns every released version (revision) of one template, each with its own
+  # 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_TYPES = KLASS_BY_TYPE.keys.freeze
+    # type => [revision model, foreign key to the klass]
+    REVISION_BY_TYPE = {
+      'element' => [::Labimotion::ElementKlassesRevision, :element_klass_id],
+      'segment' => [::Labimotion::SegmentKlassesRevision, :segment_klass_id],
+      'dataset' => [::Labimotion::DatasetKlassesRevision, :dataset_klass_id]
+    }.freeze
+
+    # rubocop:disable Metrics/BlockLength
+    # The helpers block is large due to the many template/version/DOI shaping helpers.
+    helpers do
+      def find_template(model, identifier)
+        model.find_by(identifier: identifier) || model.find_by(uuid: identifier)
+      end
+
+      # Numeric sort key for a "major.minor" version string.
+      def version_sort_key(version)
+        version.to_s.split('.').map(&:to_i)
+      end
+
+      def template_summary(record, type)
+        element_klass = record.try(:element_klass)
+        {
+          type: type,
+          identifier: record.try(:identifier),
+          uuid: record.try(:uuid),
+          name: record.try(:name),
+          label: record.try(:label),
+          desc: record.try(:desc),
+          klass_prefix: record.try(:klass_prefix),
+          icon_name: record.try(:icon_name),
+          current_version: record.try(:version),
+          element_klass: element_klass && { label: element_klass.label, icon_name: element_klass.icon_name }
+        }
+      end
+
+      def version_entry(version, released_at, uuid, properties_release)
+        { version: version, released_at: released_at, uuid: uuid, properties_release: properties_release }
+      end
+
+      # The current klass's released version is appended only when no revision
+      # already captures it, so the latest is always selectable.
+      def append_current?(record, versions)
+        record.try(:released_at).present? && versions.none? { |v| v[:version] == record.try(:version) }
+      end
+
+      # Drops blank-version entries and orders newest-first.
+      def sort_versions(versions)
+        versions.reject { |v| v[:version].to_s.strip.empty? }
+                .sort_by { |v| version_sort_key(v[:version]) }.reverse
+      end
+
+      # All released versions of a template, newest first. Built from the
+      # revision snapshots, plus the current klass (see append_current?).
+      def released_versions(record, type)
+        rev_model, foreign_key = REVISION_BY_TYPE[type]
+        scope = rev_model.where(foreign_key => record.id).where.not(released_at: nil)
+        versions = scope.map { |rev| version_entry(rev.version, rev.released_at, rev.uuid, rev.properties_release) }
+        if append_current?(record, versions)
+          versions << version_entry(record.try(:version), record.released_at,
+                                    record.try(:uuid), record.try(:properties_release))
+        end
+        sort_versions(versions)
+      end
+
+      # The template's DOI publication metadata (shown alongside the DOI).
+      def template_publication(record)
+        pub = (record.properties_template || {})['publication']
+        pub.is_a?(Hash) ? pub.slice('title', 'description', 'authors', 'license') : {}
+      end
+
+      # Released (minted) DOIs of the template, each tagged with its DOI version
+      # and its DataCite (kernel-4) metadata XML (the downloadable DOI metadata).
+      # The frontend maps a chosen template version to the applicable DOI version
+      # and shows/downloads the matching entry.
+      def released_dois(record)
+        ::Doi.labimotion_dois(record).select(&:minted).map do |doi|
+          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 }
+        end
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+
+    namespace :labimotion_template_browse do
+      route_param :type, type: String, values: KLASS_TYPES do
+        desc 'Released versions (revisions) of one template, each with properties_release'
+        params do
+          requires :identifier, type: String, desc: 'template identifier or uuid'
+        end
+        get :versions do
+          model = KLASS_BY_TYPE[params[:type]]
+          error!('unknown template type', 404) unless model
+
+          record = find_template(model, params[:identifier])
+          error!('template not found', 404) unless record
+
+          {
+            template: template_summary(record, params[:type]),
+            versions: released_versions(record, params[:type]),
+            dois: released_dois(record),
+            publication: template_publication(record)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/labimotion/entities/labimotion_template_doi_entity.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Serializes the DOI + publication state for a LabIMotion template
+  # (ElementKlass / SegmentKlass / DatasetKlass). Built ad-hoc by
+  # Labimotion::LabimotionDoiAPI; not a direct AR record entity.
+  class LabimotionTemplateDoiEntity < Grape::Entity
+    expose :type
+    expose :klass_id
+    expose :doi do |obj|
+      next nil unless obj[:doi]
+
+      {
+        id: obj[:doi].id,
+        suffix: obj[:doi].suffix,
+        full_doi: obj[:doi].full_doi,
+        version: ::Doi.labimotion_doi_version(obj[:doi]),
+        minted: obj[:doi].minted == true,
+        minted_at: obj[:doi].minted_at
+      }
+    end
+    expose :released_doi_version
+    expose :publication
+    expose :released_at
+    expose :released_by
+    expose :new_version_available
+    expose :next_doi_version
+    expose :template_url
+  end
+end

data/lib/labimotion/version.rb

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

data/lib/labimotion.rb

@@ -31,6 +31,8 @@ module Labimotion
   autoload :MttAPI, 'labimotion/apis/mtt_api'
   autoload :DoseRespRequestAPI, 'labimotion/apis/dose_resp_request_api'
   autoload :ElementVariationAPI, 'labimotion/apis/element_variation_api'
+  autoload :LabimotionDoiAPI, 'labimotion/apis/labimotion_doi_api'
+  autoload :LabimotionTemplateBrowseAPI, 'labimotion/apis/labimotion_template_browse_api'
 
   ######## Entities
   autoload :PropertiesEntity, 'labimotion/entities/properties_entity'
@@ -55,6 +57,7 @@ module Labimotion
   autoload :VocabularyEntity, 'labimotion/entities/vocabulary_entity'
   autoload :UserEntity, 'labimotion/entities/user_entity'
   autoload :ElementVariationEntity, 'labimotion/entities/element_variation_entity'
+  autoload :LabimotionTemplateDoiEntity, 'labimotion/entities/labimotion_template_doi_entity'
 
   ######## Helpers
   autoload :GenericHelpers, 'labimotion/helpers/generic_helpers'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.2.0.rc10
+  version: 2.2.0.rc11
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-19 00:00:00.000000000 Z
+date: 2026-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: caxlsx
@@ -65,7 +65,9 @@ files:
 - lib/labimotion/apis/generic_element_api.rb
 - lib/labimotion/apis/generic_klass_api.rb
 - lib/labimotion/apis/labimotion_api.rb
+- lib/labimotion/apis/labimotion_doi_api.rb
 - lib/labimotion/apis/labimotion_hub_api.rb
+- lib/labimotion/apis/labimotion_template_browse_api.rb
 - lib/labimotion/apis/mtt_api.rb
 - lib/labimotion/apis/segment_api.rb
 - lib/labimotion/apis/standard_api.rb
@@ -88,6 +90,7 @@ files:
 - lib/labimotion/entities/generic_klass_entity.rb
 - lib/labimotion/entities/generic_public_entity.rb
 - lib/labimotion/entities/klass_revision_entity.rb
+- lib/labimotion/entities/labimotion_template_doi_entity.rb
 - lib/labimotion/entities/properties_entity.rb
 - lib/labimotion/entities/segment_entity.rb
 - lib/labimotion/entities/segment_klass_entity.rb