labimotion 2.2.0.rc16 → 2.2.0.rc18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53d62c152440c37c962f7a989735fc000b5f9125e1fa47722a4083965f352aee
-  data.tar.gz: 30825b940e18998848773fec2d53c8e8239515cf8f40cc0f9ca18d77e70aecb8
+  metadata.gz: ac9e13a86048207de58add4ce3c2670dd3d3ece7b334103a4b8afef774309bd7
+  data.tar.gz: a21c3957630ea45d248eec5f49999e31424d3ea30c70b3d9b34b11dbe3105c12
 SHA512:
-  metadata.gz: 16595166f423f444eac0ad2b8e5be9e8c8b4f3334e24d23cc7b3e6a348ea3ba32a50354bd414250505943fbbef899c4bf9dc6f059f7d9ab172e949b6c817a05b
-  data.tar.gz: d6b47a16615e8af50a0026b1288d8f9d59369e7a4751f0d4b5f13e957e8fcbb7f92b4ee15d833e3a791b7c6ed6b2c3773e4de709b2847d920bc0126dc1ce3485
+  metadata.gz: 7ec1e065535fe7fbfa1c94f82f1f5f06057857aa6439b41fab7e8570b4b584276a9625fd5d806431a6abe3307b147107f6e91469c65b351bcf3b5a9f868d8d83
+  data.tar.gz: 4ab8e424d00107d029dbe0cdd97740a2d2470994121c1d82b40fd902c5bbd1d1712849756da75631f675666ee39f09a4d56f0839452eb0a29a9b8a78c1ef37bc

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,9 +14,9 @@ module Labimotion
     mount Labimotion::VocabularyAPI
     mount Labimotion::UserAPI
     mount Labimotion::MttAPI
-    mount Labimotion::DoseRespRequestAPI
     mount Labimotion::ElementVariationAPI
     mount Labimotion::LabimotionDoiAPI
     mount Labimotion::LabimotionTemplateBrowseAPI
+    mount Labimotion::WellplateAPI
   end
 end

data/lib/labimotion/apis/mtt_api.rb

@@ -29,46 +29,19 @@ module Labimotion
 
     resource :mtt do
       namespace :requests do
-        desc 'Get MTT requests for current user'
+        desc 'Get MTT requests for current user, scoped to a single element'
+        params do
+          requires :element_id, type: Integer, desc: 'Only return requests for this element'
+        end
         get do
-          # Get all requests created by current user
+          # Get requests created by current user for the selected element only
           requests = Labimotion::DoseRespRequest
                      .includes(:dose_resp_outputs)
-                     .where(created_by: current_user.id)
+                     .where(created_by: current_user.id, element_id: params[:element_id])
                      .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 +105,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 +150,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 +189,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/apis/wellplate_api.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # API for wellplates linked to a generic element
+  class WellplateAPI < Grape::API
+    resource :wellplates do
+      namespace :by_generic_element do
+        desc 'Get wellplates for a generic element'
+        params do
+          requires :element_id, type: Integer, desc: 'Generic element id'
+        end
+        route_param :element_id do
+          get do
+            element = Labimotion::Element.find_by(id: params[:element_id])
+            error!('404 Not Found', 404) unless element
+            error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, element).read?
+
+            wellplate_ids = Labimotion::ElementsWellplate.where(element_id: element.id).pluck(:wellplate_id)
+            wellplates = Wellplate.where(id: wellplate_ids)
+                                  .includes(:wells, wells: :sample)
+
+            serialized_wellplates = wellplates.map do |wellplate|
+              detail_levels = ElementDetailLevelCalculator.new(user: current_user, element: wellplate).detail_levels
+              Entities::WellplateEntity.represent(wellplate, detail_levels: detail_levels)
+            end
+
+            { wellplates: serialized_wellplates }
+          end
+
+          desc 'Update wellplates for a generic element'
+          params do
+            requires :wellplate_ids, type: Array, desc: 'Wellplate IDs'
+          end
+          put do
+            element = Labimotion::Element.find_by(id: params[:element_id])
+            error!('404 Not Found', 404) unless element
+            error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, element).update?
+
+            ActiveRecord::Base.transaction do
+              current_ids = Labimotion::ElementsWellplate.where(element_id: element.id).pluck(:wellplate_id)
+              new_ids = params[:wellplate_ids] || []
+
+              ids_to_remove = current_ids - new_ids
+              if ids_to_remove.any?
+                Labimotion::ElementsWellplate.where(element_id: element.id, wellplate_id: ids_to_remove).destroy_all
+              end
+
+              ids_to_add = new_ids - current_ids
+              ids_to_add.each do |wellplate_id|
+                Labimotion::ElementsWellplate.create!(element_id: element.id, wellplate_id: wellplate_id)
+              end
+            end
+
+            { wellplate_ids: Labimotion::ElementsWellplate.where(element_id: element.id).pluck(:wellplate_id) }
+          end
+        end
+      end
+    end
+  end
+end

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/libs/data/mapper/Source.json

@@ -9,7 +9,6 @@
       "file": "acqus",
       "parameters": [
         "DATE",
-        "D1",
         "INSTRUM",
         "NS",
         "NUC1",
@@ -23,7 +22,10 @@
         "TD",
         "TE",
         "TITLE"
-      ]
+      ],
+      "arrayParameters": {
+        "D1": { "name": "D", "index": 1 }
+      }
     },
     "procs": {
       "file": "pdata/1/procs",

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/models/elements_wellplate.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class ElementsWellplate < ApplicationRecord
+    acts_as_paranoid
+    self.table_name = :elements_wellplates
+    belongs_to :element, class_name: 'Labimotion::Element'
+    belongs_to :wellplate
+  end
+end

data/lib/labimotion/utils/mapper_utils.rb

@@ -70,6 +70,37 @@ module Labimotion
         extracted_parameters
       end
 
+      # Extracts scalar values from Bruker array parameters such as
+      #   ##$D= (0..63)
+      #   0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.0002 ...
+      # where the values live on the line(s) following the header. The config maps
+      # each output key to an array name + index, e.g.
+      #   { "D1" => { "name" => "D", "index" => 1 } } => D1 = the 2nd value (here 1).
+      def extract_array_parameters(file_content, array_parameters)
+        return {} if file_content.blank? || array_parameters.blank?
+
+        lines = file_content.lines
+        extracted = {}
+        lines.each_with_index do |line, idx|
+          header = line.match(/^\s*##\$(?<name>[A-Za-z0-9_]+)\s*=\s*\(\s*\d+\s*\.\.\s*\d+\s*\)/)
+          next unless header
+
+          targets = array_parameters.select { |_key, cfg| cfg['name'] == header[:name] }
+          next if targets.empty?
+
+          values = collect_array_values(lines, idx + 1)
+          targets.each do |out_key, cfg|
+            value = values[cfg['index'].to_i]
+            extracted[out_key] = clean_value(value) if value.present?
+          end
+        end
+        extracted.compact_blank!
+        extracted
+      rescue StandardError => e
+        Rails.logger.error "Error extracting array parameters: #{e.message}"
+        {}
+      end
+
       def format_timestamp(timestamp_str, give_format = nil)
         return nil if timestamp_str.blank?
 
@@ -118,6 +149,21 @@ module Labimotion
         value
       end
 
+      # Collects whitespace-separated values from the line(s) following an array
+      # header, stopping at the next directive (line starting with '##') or a blank line.
+      def collect_array_values(lines, start_index)
+        values = []
+        index = start_index
+        while index < lines.length
+          stripped = lines[index].strip
+          break if stripped.empty? || stripped.start_with?('##')
+
+          values.concat(stripped.split(/\s+/))
+          index += 1
+        end
+        values
+      end
+
       def process_zip_file(zip_file_url, source_map)
         final_parameters = {}
 
@@ -137,23 +183,28 @@ module Labimotion
 
         zip_file.each do |entry|
           if source_file?(entry, source_config)
-            process_file_entry(entry, source_config['parameters'], final_parameters)
+            process_file_entry(entry, source_config, final_parameters)
           elsif bagit_metadata_file?(entry)
             return { is_bagit: true, metadata: nil }
           end
         end
       end
 
-      def process_file_entry(entry, parameters, final_parameters)
+      def process_file_entry(entry, source_config, final_parameters)
         file_content = entry.get_input_stream.read.force_encoding(Constants::File::ENCODING)
-        extracted_parameters = extract_parameters(file_content, parameters)
+        extracted_parameters = extract_parameters(file_content, source_config['parameters'])
         final_parameters.merge!(extracted_parameters) if extracted_parameters.present?
+
+        # Array parameters (e.g. D1 from acqus ##$D) are a fallback: they only fill a
+        # value that an earlier/higher-priority source (e.g. parm.txt D1) did not provide.
+        array_parameters = extract_array_parameters(file_content, source_config['arrayParameters'])
+        final_parameters.reverse_merge!(array_parameters) if array_parameters.present?
       end
 
       def invalid_source_config?(source_config)
         source_config.nil? ||
           source_config['file'].nil? ||
-          source_config['parameters'].nil?
+          (source_config['parameters'].nil? && source_config['arrayParameters'].nil?)
       end
 
       def source_file?(entry, source_config)

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.rc16'
+  VERSION = '2.2.0.rc18'
 end

data/lib/labimotion.rb

@@ -29,10 +29,10 @@ 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'
+  autoload :WellplateAPI, 'labimotion/apis/wellplate_api'
 
   ######## Entities
   autoload :PropertiesEntity, 'labimotion/entities/properties_entity'
@@ -124,6 +124,7 @@ module Labimotion
 
   autoload :ElementsSample, 'labimotion/models/elements_sample'
   autoload :ElementsElement, 'labimotion/models/elements_element'
+  autoload :ElementsWellplate, 'labimotion/models/elements_wellplate'
   autoload :CollectionsElement, 'labimotion/models/collections_element'
 
   autoload :StdLayer, 'labimotion/models/std_layer'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.2.0.rc16
+  version: 2.2.0.rc18
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-22 00:00:00.000000000 Z
+date: 2026-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: caxlsx
@@ -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
@@ -74,6 +73,7 @@ files:
 - lib/labimotion/apis/standard_layer_api.rb
 - lib/labimotion/apis/user_api.rb
 - lib/labimotion/apis/vocabulary_api.rb
+- lib/labimotion/apis/wellplate_api.rb
 - lib/labimotion/collection/export.rb
 - lib/labimotion/collection/import.rb
 - lib/labimotion/conf.rb
@@ -151,6 +151,7 @@ files:
 - lib/labimotion/models/elements_element.rb
 - lib/labimotion/models/elements_revision.rb
 - lib/labimotion/models/elements_sample.rb
+- lib/labimotion/models/elements_wellplate.rb
 - lib/labimotion/models/hub_log.rb
 - lib/labimotion/models/reaction.rb
 - lib/labimotion/models/research_plan.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