labimotion 2.2.0.rc13 → 2.2.0.rc16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ec9d0808468d0b4447f577e3932d0e421c248020df87eeee277a5242fc3a0e6
-  data.tar.gz: de0e10512eb0ce1e0bb72fc60983119637c869e43816aed20c0f88419a474d37
+  metadata.gz: 53d62c152440c37c962f7a989735fc000b5f9125e1fa47722a4083965f352aee
+  data.tar.gz: 30825b940e18998848773fec2d53c8e8239515cf8f40cc0f9ca18d77e70aecb8
 SHA512:
-  metadata.gz: eb60f1b75b504783636051ee83553e44b8edd71c03cf42abdfd8187405bd53ab150d5a136c7321a4a29b3a6a947aa397fba77b2ee8df180674a61f22b3c08ed5
-  data.tar.gz: 8cbad024d4e4b12275eb2fe938fcfcbf8540ab85f1d03cd6d86059ed4aa51bc5c2c555aa1c14e8a823031d74c6107f133fe302c5cea522ef901b8a1e305a97e9
+  metadata.gz: 16595166f423f444eac0ad2b8e5be9e8c8b4f3334e24d23cc7b3e6a348ea3ba32a50354bd414250505943fbbef899c4bf9dc6f059f7d9ab172e949b6c817a05b
+  data.tar.gz: d6b47a16615e8af50a0026b1288d8f9d59369e7a4751f0d4b5f13e957e8fcbb7f92b4ee15d833e3a791b7c6ed6b2c3773e4de709b2847d920bc0126dc1ce3485

data/lib/labimotion/apis/dose_resp_request_api.rb

@@ -0,0 +1,241 @@
+# 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

data/lib/labimotion/apis/generic_element_api.rb

@@ -432,6 +432,7 @@ 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,6 +14,7 @@ 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,7 +38,37 @@ module Labimotion
                      .order(created_at: :desc)
 
           # Return formatted response
-          requests.map { |req| mtt_request_json(req, include_outputs: true) }
+          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
         end
 
         desc 'Delete one or multiple MTT requests'
@@ -102,7 +132,13 @@ module Labimotion
                 id: request.id,
                 request_id: request.request_id,
                 state: request.state,
-                state_name: mtt_state_name(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,
                 resp_message: request.resp_message,
                 revoked: request.revoked?,
                 updated_at: request.updated_at
@@ -147,34 +183,6 @@ 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
@@ -186,7 +194,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,21 +247,27 @@ module Labimotion
     end
 
     def list_serialized_elements(params, current_user)
-      scope = Labimotion::Element.none
-
+      collection_id =
       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
+        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 =
+      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)
       else
-        # All collection of current_user
-        scope = Labimotion::Element.for_user(current_user.id)
+        Labimotion::Element.none
       end
 
       ## TO DO: refactor labimotion
@@ -272,7 +278,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,98 +25,6 @@ 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 records
+        # Shared (synced) records
         shared = apply_filters.call(
-          left_joins(:collection_shares).where(collection_shares: { shared_with_id: user_id })
+          joins(collections: :sync_collections_users).where(sync_collections_users: { user_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 elements
+      # Shared (synced) elements
       shared = apply_filters.call(
-        left_joins(:collection_shares).where(collection_shares: { shared_with_id: user_id })
+        joins(collections: :sync_collections_users).where(sync_collections_users: { user_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.accessible_for(current_user).find(c_id)
+      collection = Collection.belongs_to_or_shared_by(current_user.id, current_user.group_ids).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.accessible_for(current_user).find(c_id)
+      collection = Collection.belongs_to_or_shared_by(current_user.id, current_user.group_ids).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.rc13'
+  VERSION = '2.2.0.rc16'
 end

data/lib/labimotion.rb

@@ -29,6 +29,7 @@ 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'
@@ -71,6 +72,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.rc16
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -58,6 +58,7 @@ 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
@@ -164,6 +165,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