labimotion 2.2.0.rc11 → 2.2.0.rc13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 491f3e3075c83954b5e49caeb8b091d1aba68ddf0135fe82ddbaf6aeb4b244e9
-  data.tar.gz: ae5dc4a93ecb31559feff1060f8fb449aa3e618f86890ea25324410226f4d166
+  metadata.gz: 0ec9d0808468d0b4447f577e3932d0e421c248020df87eeee277a5242fc3a0e6
+  data.tar.gz: de0e10512eb0ce1e0bb72fc60983119637c869e43816aed20c0f88419a474d37
 SHA512:
-  metadata.gz: ce1f326748ee1ae7c9a71f97f43b2eef7d3273c28c9d7d7d3e87516cfcef58002927563dedbaad66ca87f6c396fd462cab6f827eb95d052cdf4f2703bfe8e307
-  data.tar.gz: 958083e170c64e0c378b38ecf9996343a88dfa6756617d0a7d6d9e548d3dbefc3b53c00eda2ec8412fd6da59ca3b959b7d0fa20f67e32a559fa74da9d01e695b
+  metadata.gz: eb60f1b75b504783636051ee83553e44b8edd71c03cf42abdfd8187405bd53ab150d5a136c7321a4a29b3a6a947aa397fba77b2ee8df180674a61f22b3c08ed5
+  data.tar.gz: 8cbad024d4e4b12275eb2fe938fcfcbf8540ab85f1d03cd6d86059ed4aa51bc5c2c555aa1c14e8a823031d74c6107f133fe302c5cea522ef901b8a1e305a97e9

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/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/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/version.rb

@@ -2,5 +2,5 @@
 
 ## Labimotion Version
 module Labimotion
-  VERSION = '2.2.0.rc11'
+  VERSION = '2.2.0.rc13'
 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'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.2.0.rc11
+  version: 2.2.0.rc13
 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

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