labimotion 2.2.0.rc12 → 2.2.0.rc14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 407197c03e88402882b081d31dc92999629ec43c25b8c056c6f6ba3ca40135fc
-  data.tar.gz: d331368ce985ae7ff32a98f0747e9b06233eb5ac3b9b1a0c17e76a3ecbeeab7a
+  metadata.gz: 92bb0da102b4ac516f423c274a21bb59a08fffecb2d451d0f1d5caee8631d5af
+  data.tar.gz: e25335102afc9aa97669c3c09f671f64fa2102344fa2764817b6fe9556638359
 SHA512:
-  metadata.gz: 275089d4170573e9961387dfe2274e9c5c8d1f9ccfe02b854aec3b1a5bfb237f5535915fd73205fc1efa564102ef33605a4f5de148fec8244b76ee2ca9fa5b48
-  data.tar.gz: 75b3433050aab3b9a76c9442643b0c5dcb87b508672d4b3b1c57b8ca52bbb75e1045cf429c25c4cfa64616df2482baa15062ccc45f515173012f31ca6cbcacef
+  metadata.gz: f9f574b0057178c25cb0624bd11370757adf1992e8f5734a7492ac380dadd779d06c83accabe1e59c07e189ce316258da0a8177b2c42fa028f4aaf418245fbda
+  data.tar.gz: f9d629342ffead4be91ce5728d2048a56b9de3da660df32b962d549756391ca34758edf7e1392e3aefbd117d185ff179cda085e59f4d5ad4b20e802fbdcbf060

data/lib/labimotion/apis/generic_element_api.rb

@@ -432,7 +432,6 @@ module Labimotion
       desc 'Return serialized elements of current user'
       params do
         optional :collection_id, type: Integer, desc: 'Collection id'
-        optional :sync_collection_id, type: Integer, desc: 'SyncCollectionsUser id'
         optional :el_type, type: String, desc: 'element klass name'
         optional :from_date, type: Integer, desc: 'created_date from in ms'
         optional :to_date, type: Integer, desc: 'created_date to in ms'

data/lib/labimotion/apis/labimotion_api.rb

@@ -14,7 +14,6 @@ module Labimotion
     mount Labimotion::VocabularyAPI
     mount Labimotion::UserAPI
     mount Labimotion::MttAPI
-    mount Labimotion::DoseRespRequestAPI
     mount Labimotion::ElementVariationAPI
     mount Labimotion::LabimotionDoiAPI
     mount Labimotion::LabimotionTemplateBrowseAPI

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/apis/mtt_api.rb

@@ -38,37 +38,7 @@ module Labimotion
                      .order(created_at: :desc)
 
           # Return formatted response
-          requests.map do |req|
-            {
-              id: req.id,
-              request_id: req.request_id,
-              element_id: req.element_id,
-              state: req.state,
-              state_name: case req.state
-                          when Labimotion::DoseRespRequest::STATE_ERROR then 'error'
-                          when Labimotion::DoseRespRequest::STATE_INITIAL then 'initial'
-                          when Labimotion::DoseRespRequest::STATE_PROCESSING then 'processing'
-                          when Labimotion::DoseRespRequest::STATE_COMPLETED then 'completed'
-                          else 'unknown'
-                          end,
-              created_at: req.created_at,
-              expires_at: req.expires_at,
-              expired: req.expired?,
-              revoked: req.revoked?,
-              active: req.active?,
-              resp_message: req.resp_message,
-              last_accessed_at: req.last_accessed_at,
-              access_count: req.access_count || 0,
-              outputs: req.dose_resp_outputs.map do |output|
-                {
-                  id: output.id,
-                  output_data: output.output_data,
-                  notes: output.notes,
-                  created_at: output.created_at
-                }
-              end
-            }
-          end
+          requests.map { |req| mtt_request_json(req, include_outputs: true) }
         end
 
         desc 'Delete one or multiple MTT requests'
@@ -132,13 +102,7 @@ module Labimotion
                 id: request.id,
                 request_id: request.request_id,
                 state: request.state,
-                state_name: case request.state
-                            when Labimotion::DoseRespRequest::STATE_ERROR then 'error'
-                            when Labimotion::DoseRespRequest::STATE_INITIAL then 'initial'
-                            when Labimotion::DoseRespRequest::STATE_PROCESSING then 'processing'
-                            when Labimotion::DoseRespRequest::STATE_COMPLETED then 'completed'
-                            else 'unknown'
-                            end,
+                state_name: mtt_state_name(request.state),
                 resp_message: request.resp_message,
                 revoked: request.revoked?,
                 updated_at: request.updated_at
@@ -183,6 +147,34 @@ module Labimotion
         rescue StandardError => e
           error!("Error deleting outputs: #{e.message}", 500)
         end
+
+        desc 'Delete a single result (by sample name) from an output'
+        params do
+          requires :id, type: Integer, desc: 'Output ID'
+          requires :sample_name, type: String, desc: 'Sample name (result[].name) to remove'
+        end
+        delete ':id/results' do
+          # Only operate on outputs whose parent request belongs to the current user
+          output = Labimotion::DoseRespOutput
+                   .joins(:dose_resp_request)
+                   .where(dose_resp_requests: { created_by: current_user.id })
+                   .find_by(id: params[:id])
+
+          error!('Output not found or unauthorized', 404) unless output
+
+          outcome = remove_mtt_result_by_sample_name(output, params[:sample_name])
+          error!('Result not found in output', 404) unless outcome[:removed]
+
+          {
+            success: true,
+            message: "Removed result '#{params[:sample_name]}' from output #{params[:id]}",
+            output_id: params[:id],
+            output_deleted: outcome[:output_deleted],
+            output: outcome[:output_deleted] ? nil : mtt_output_json(output)
+          }
+        rescue StandardError => e
+          error!("Error deleting result: #{e.message}", 500)
+        end
       end
 
       namespace :create_mtt_request do
@@ -194,7 +186,7 @@ module Labimotion
           # Find element and wellplates
           element = Labimotion::Element.find_by(id: params[:id])
           error!('Element not found', 404) unless element
-#byebug
+
           # Verify user has update permission
           error!('Unauthorized', 403) unless ElementPolicy.new(current_user, element).update?
 

data/lib/labimotion/helpers/element_helpers.rb

@@ -215,7 +215,7 @@ module Labimotion
         layer, field = params[:sort_column].split('.')
 
         element_klass = Labimotion::ElementKlass.find_by(name: params[:el_type])
-        allowed_fields = element_klass.properties_release.dig(Labimotion::Prop::LAYERS, layer, Labimotion::Prop::FIELDS)&.pluck('field') || []
+        allowed_fields = element_klass&.properties_release&.dig(Labimotion::Prop::LAYERS, layer, Labimotion::Prop::FIELDS)&.pluck('field') || []
 
         if field.in?(allowed_fields)
           query = ActiveRecord::Base.sanitize_sql(
@@ -247,27 +247,21 @@ module Labimotion
     end
 
     def list_serialized_elements(params, current_user)
-      collection_id =
-      if params[:collection_id]
-        Collection
-          .belongs_to_or_shared_by(current_user.id, current_user.group_ids)
-          .find_by(id: params[:collection_id])&.id
-      elsif params[:sync_collection_id]
-        current_user
-          .all_sync_in_collections_users
-          .find_by(id: params[:sync_collection_id])&.collection&.id
-      end
+      scope = Labimotion::Element.none
 
-      scope =
-      if collection_id
-        Labimotion::Element
-          .joins(:element_klass, :collections_elements)
-          .where(
-            element_klasses: { name: params[:el_type] },
-            collections_elements: { collection_id: collection_id },
-          ).includes(:tag, collections: :sync_collections_users)
+      if params[:collection_id]
+        begin
+          collection = Collection.accessible_for(current_user).find(params[:collection_id])
+          scope = collection.elements
+                            .joins(:element_klass)
+                            .where(element_klasses: { name: params[:el_type] })
+                            .includes(:tag)
+        rescue ActiveRecord::RecordNotFound
+          Labimotion::Element.none
+        end
       else
-        Labimotion::Element.none
+        # All collection of current_user
+        scope = Labimotion::Element.for_user(current_user.id)
       end
 
       ## TO DO: refactor labimotion
@@ -278,7 +272,7 @@ module Labimotion
         layer, field = params[:sort_column].split('.')
 
         element_klass = Labimotion::ElementKlass.find_by(name: params[:el_type])
-        allowed_fields = element_klass.properties_release.dig(Labimotion::Prop::LAYERS, layer, Labimotion::Prop::FIELDS)&.pluck('field') || []
+        allowed_fields = element_klass&.properties_release&.dig(Labimotion::Prop::LAYERS, layer, Labimotion::Prop::FIELDS)&.pluck('field') || []
 
         if field.in?(allowed_fields)
           query = ActiveRecord::Base.sanitize_sql(

data/lib/labimotion/helpers/mtt_helpers.rb

@@ -25,6 +25,98 @@ module Labimotion
       ENV['MTT_EXTERNAL_APP_URL'] || 'http://localhost:4050'
     end
 
+    # --- Serialization helpers (shared across the MTT request endpoints) ---
+
+    def mtt_state_name(state)
+      case state
+      when Labimotion::DoseRespRequest::STATE_ERROR then 'error'
+      when Labimotion::DoseRespRequest::STATE_INITIAL then 'initial'
+      when Labimotion::DoseRespRequest::STATE_PROCESSING then 'processing'
+      when Labimotion::DoseRespRequest::STATE_COMPLETED then 'completed'
+      else 'unknown'
+      end
+    end
+
+    def mtt_output_json(output)
+      {
+        id: output.id,
+        output_data: output.output_data,
+        notes: output.notes,
+        created_at: output.created_at
+      }
+    end
+
+    def mtt_request_json(req, include_outputs: false)
+      json = {
+        id: req.id,
+        request_id: req.request_id,
+        element_id: req.element_id,
+        state: req.state,
+        state_name: mtt_state_name(req.state),
+        created_at: req.created_at,
+        expires_at: req.expires_at,
+        expired: req.expired?,
+        revoked: req.revoked?,
+        active: req.active?,
+        resp_message: req.resp_message,
+        last_accessed_at: req.last_accessed_at,
+        access_count: req.access_count || 0
+      }
+      json[:outputs] = req.dose_resp_outputs.map { |output| mtt_output_json(output) } if include_outputs
+      json
+    end
+
+    # The sample name of a result node, i.e. result[0].name. Used to match a
+    # single result row across both output_data shapes (see below). JSONB columns
+    # deserialize with string keys; symbol keys are tolerated defensively.
+    def mtt_result_name(node)
+      return nil unless node.is_a?(Hash)
+
+      result = node['result'] || node[:result]
+      return nil unless result.is_a?(Array) && result.first.is_a?(Hash)
+
+      result.first['name'] || result.first[:name]
+    end
+
+    # Remove a single result row (matched by sample name) from an output's
+    # output_data JSON, supporting both the new (Output[].items[]) and the legacy
+    # (Output[].result[]) shapes. If the output has no results left afterwards the
+    # record is soft-deleted (acts_as_paranoid), consistent with the bulk delete.
+    #
+    # Returns { removed:, output_deleted: }.
+    def remove_mtt_result_by_sample_name(output, sample_name)
+      data = output.output_data || {}
+      groups = data['Output'] || data[:Output]
+      return { removed: false, output_deleted: false } unless groups.is_a?(Array)
+
+      removed = false
+      new_groups = groups.map do |group|
+        items = group['items'] || group[:items]
+        if items.is_a?(Array)
+          # New structure: drop the matching item(s) from the group.
+          kept = items.reject { |item| mtt_result_name(item) == sample_name }
+          removed ||= kept.length != items.length
+          kept.empty? ? nil : group.merge('items' => kept)
+        elsif mtt_result_name(group) == sample_name
+          # Legacy structure: drop the whole group.
+          removed = true
+          nil
+        else
+          group
+        end
+      end.compact
+
+      return { removed: false, output_deleted: false } unless removed
+
+      if new_groups.empty?
+        output.destroy
+        { removed: true, output_deleted: true }
+      else
+        output.update!(output_data: data.merge('Output' => new_groups))
+        { removed: true, output_deleted: false }
+      end
+    end
+
     def validate_token(token)
       # Find the request by access token
       request = Labimotion::DoseRespRequest.find_by(access_token: token)

data/lib/labimotion/models/concerns/element_fetchable.rb

@@ -26,9 +26,9 @@ module Labimotion
           joins(collections: :user).where(collections: { user_id: user_id })
         )
 
-        # Shared (synced) records
+        # Shared records
         shared = apply_filters.call(
-          joins(collections: :sync_collections_users).where(sync_collections_users: { user_id: user_id })
+          left_joins(:collection_shares).where(collection_shares: { shared_with_id: user_id })
         )
 
         # Combine (remove duplicates), order, and limit

data/lib/labimotion/models/element.rb

@@ -141,9 +141,9 @@ module Labimotion
         joins(collections: :user).where(collections: { user_id: user_id })
       )
 
-      # Shared (synced) elements
+      # Shared elements
       shared = apply_filters.call(
-        joins(collections: :sync_collections_users).where(sync_collections_users: { user_id: user_id })
+        left_joins(:collection_shares).where(collection_shares: { shared_with_id: user_id })
       )
 
       # Combine (remove duplicates), order, and limit

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/utils/search.rb

@@ -12,7 +12,7 @@ module Labimotion
     end
 
     def self.elements_search(params, current_user, c_id, dl)
-      collection = Collection.belongs_to_or_shared_by(current_user.id, current_user.group_ids).find(c_id)
+      collection = Collection.accessible_for(current_user).find(c_id)
       element_scope = Labimotion::Element.joins(:collections_elements).where('collections_elements.collection_id = ?', collection.id).joins(:element_klass).where('element_klasses.id = elements.element_klass_id AND element_klasses.name = ?', params[:selection][:genericElName])
       element_scope = element_scope.where('elements.name like (?)', "%#{params[:selection][:searchName]}%") if params[:selection][:searchName].present?
       element_scope = element_scope.where('elements.short_label like (?)', "%#{params[:selection][:searchShowLabel]}%") if params[:selection][:searchShowLabel].present?
@@ -97,7 +97,7 @@ module Labimotion
     def self.samples_search(c_id = @c_id)
       sqls = []
       sps = params[:selection][:searchProperties]
-      collection = Collection.belongs_to_or_shared_by(current_user.id, current_user.group_ids).find(c_id)
+      collection = Collection.accessible_for(current_user).find(c_id)
       element_scope = Sample.joins(:collections_samples).where('collections_samples.collection_id = ?', collection.id)
       return element_scope if sps.empty?
 

data/lib/labimotion/version.rb

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

data/lib/labimotion.rb

@@ -29,7 +29,6 @@ module Labimotion
   autoload :VocabularyAPI, 'labimotion/apis/vocabulary_api'
   autoload :UserAPI, 'labimotion/apis/user_api'
   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'
@@ -72,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.rc12
+  version: 2.2.0.rc14
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -58,7 +58,6 @@ files:
 - README.md
 - lib/labimotion.rb
 - lib/labimotion/apis/converter_api.rb
-- lib/labimotion/apis/dose_resp_request_api.rb
 - lib/labimotion/apis/element_variation_api.rb
 - lib/labimotion/apis/exporter_api.rb
 - lib/labimotion/apis/generic_dataset_api.rb
@@ -165,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

data/lib/labimotion/apis/dose_resp_request_api.rb

@@ -1,241 +0,0 @@
-# frozen_string_literal: true
-
-require 'labimotion/version'
-
-module Labimotion
-  # Dose Response Request API
-  class DoseRespRequestAPI < Grape::API
-    helpers Labimotion::ParamHelpers
-
-    resource :dose_resp_requests do
-      desc 'Get all dose response requests for current user'
-      params do
-        optional :element_id, type: Integer, desc: 'Filter by element ID'
-        optional :state, type: Integer, desc: 'Filter by state (-1, 0, 1, 2)'
-        optional :page, type: Integer, desc: 'Page number', default: 1
-        optional :per_page, type: Integer, desc: 'Items per page', default: 20
-      end
-      get do
-        requests = Labimotion::DoseRespRequest.where(created_by: current_user.id)
-
-        # Apply filters
-        requests = requests.where(element_id: params[:element_id]) if params[:element_id]
-        requests = requests.where(state: params[:state]) if params[:state]
-
-        # Pagination
-        page = params[:page] || 1
-        per_page = [params[:per_page] || 20, 100].min # Max 100 per page
-
-        total = requests.count
-        requests = requests.order(created_at: :desc)
-                          .offset((page - 1) * per_page)
-                          .limit(per_page)
-
-        {
-          requests: requests.map do |req|
-            {
-              id: req.id,
-              request_id: req.request_id,
-              element_id: req.element_id,
-              state: req.state,
-              state_label: state_label(req.state),
-              expires_at: req.expires_at,
-              created_at: req.created_at,
-              updated_at: req.updated_at,
-              first_accessed_at: req.first_accessed_at,
-              last_accessed_at: req.last_accessed_at,
-              access_count: req.access_count,
-              resp_message: req.resp_message,
-              active: req.active?
-            }
-          end,
-          pagination: {
-            page: page,
-            per_page: per_page,
-            total: total,
-            total_pages: (total.to_f / per_page).ceil
-          }
-        }
-      rescue StandardError => e
-        error!("Error: #{e.message}", 500)
-      end
-
-      desc 'Get a dose response request by ID'
-      params do
-        requires :id, type: Integer, desc: 'Request ID'
-      end
-      get ':id' do
-        request = Labimotion::DoseRespRequest.find_by(id: params[:id])
-        error!('Request not found', 404) unless request
-
-        # Check authorization
-        error!('Unauthorized', 403) unless request.created_by == current_user.id
-
-        {
-          id: request.id,
-          request_id: request.request_id,
-          element_id: request.element_id,
-          state: request.state,
-          state_label: state_label(request.state),
-          wellplates_metadata: request.wellplates_metadata,
-          input_metadata: request.input_metadata,
-          expires_at: request.expires_at,
-          revoked_at: request.revoked_at,
-          created_at: request.created_at,
-          updated_at: request.updated_at,
-          first_accessed_at: request.first_accessed_at,
-          last_accessed_at: request.last_accessed_at,
-          access_count: request.access_count,
-          resp_message: request.resp_message,
-          active: request.active?,
-          expired: request.expired?,
-          revoked: request.revoked?
-        }
-      rescue StandardError => e
-        error!("Error: #{e.message}", 500)
-      end
-
-      desc 'Update a dose response request'
-      params do
-        requires :id, type: Integer, desc: 'Request ID'
-        optional :state, type: Integer, desc: 'State', values: [-1, 0, 1, 2]
-        optional :resp_message, type: String, desc: 'Response message'
-        optional :wellplates_metadata, type: Hash, desc: 'Wellplates metadata'
-      end
-      put ':id' do
-        request = Labimotion::DoseRespRequest.find_by(id: params[:id])
-        error!('Request not found', 404) unless request
-
-        # Check authorization
-        error!('Unauthorized', 403) unless request.created_by == current_user.id
-
-        update_params = {}
-        update_params[:state] = params[:state] if params[:state]
-        update_params[:resp_message] = params[:resp_message] if params[:resp_message]
-        update_params[:wellplates_metadata] = params[:wellplates_metadata] if params[:wellplates_metadata]
-
-        request.update!(update_params)
-
-        {
-          success: true,
-          message: 'Request updated successfully',
-          request: {
-            id: request.id,
-            request_id: request.request_id,
-            state: request.state,
-            state_label: state_label(request.state),
-            resp_message: request.resp_message,
-            updated_at: request.updated_at
-          }
-        }
-      rescue ActiveRecord::RecordInvalid => e
-        error!("Validation error: #{e.message}", 422)
-      rescue StandardError => e
-        error!("Error: #{e.message}", 500)
-      end
-
-      desc 'Revoke a dose response request'
-      params do
-        requires :id, type: Integer, desc: 'Request ID'
-      end
-      post ':id/revoke' do
-        request = Labimotion::DoseRespRequest.find_by(id: params[:id])
-        error!('Request not found', 404) unless request
-
-        # Check authorization
-        error!('Unauthorized', 403) unless request.created_by == current_user.id
-
-        request.revoke!
-
-        {
-          success: true,
-          message: 'Request revoked successfully',
-          request: {
-            id: request.id,
-            request_id: request.request_id,
-            state: request.state,
-            revoked_at: request.revoked_at,
-            active: request.active?
-          }
-        }
-      rescue StandardError => e
-        error!("Error: #{e.message}", 500)
-      end
-
-      desc 'Delete a dose response request'
-      params do
-        requires :id, type: Integer, desc: 'Request ID'
-      end
-      delete ':id' do
-        request = Labimotion::DoseRespRequest.find_by(id: params[:id])
-        error!('Request not found', 404) unless request
-
-        # Check authorization
-        error!('Unauthorized', 403) unless request.created_by == current_user.id
-
-        # Soft delete if acts_as_paranoid is enabled
-        request.destroy
-
-        {
-          success: true,
-          message: 'Request deleted successfully'
-        }
-      rescue StandardError => e
-        error!("Error: #{e.message}", 500)
-      end
-
-      desc 'Get dose response requests by element ID'
-      params do
-        requires :element_id, type: Integer, desc: 'Element ID'
-      end
-      get 'by_element/:element_id' do
-        element = Labimotion::Element.find_by(id: params[:element_id])
-        error!('Element not found', 404) unless element
-
-        # Check if user has access to element
-        policy = ElementPolicy.new(current_user, element)
-        error!('Unauthorized', 403) unless policy.read?
-
-        requests = Labimotion::DoseRespRequest.where(element_id: params[:element_id])
-                                               .where(created_by: current_user.id)
-                                               .order(created_at: :desc)
-
-        {
-          element_id: element.id,
-          element_name: element.name,
-          requests: requests.map do |req|
-            {
-              id: req.id,
-              request_id: req.request_id,
-              state: req.state,
-              state_label: state_label(req.state),
-              expires_at: req.expires_at,
-              created_at: req.created_at,
-              access_count: req.access_count,
-              active: req.active?
-            }
-          end
-        }
-      rescue StandardError => e
-        error!("Error: #{e.message}", 500)
-      end
-    end
-
-    helpers do
-      def state_label(state)
-        case state
-        when Labimotion::DoseRespRequest::STATE_ERROR
-          'error'
-        when Labimotion::DoseRespRequest::STATE_INITIAL
-          'initial'
-        when Labimotion::DoseRespRequest::STATE_PROCESSING
-          'processing'
-        when Labimotion::DoseRespRequest::STATE_COMPLETED
-          'completed'
-        else
-          'unknown'
-        end
-      end
-    end
-  end
-end