labimotion 2.2.0.rc14 → 2.2.0.rc16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92bb0da102b4ac516f423c274a21bb59a08fffecb2d451d0f1d5caee8631d5af
-  data.tar.gz: e25335102afc9aa97669c3c09f671f64fa2102344fa2764817b6fe9556638359
+  metadata.gz: 53d62c152440c37c962f7a989735fc000b5f9125e1fa47722a4083965f352aee
+  data.tar.gz: 30825b940e18998848773fec2d53c8e8239515cf8f40cc0f9ca18d77e70aecb8
 SHA512:
-  metadata.gz: f9f574b0057178c25cb0624bd11370757adf1992e8f5734a7492ac380dadd779d06c83accabe1e59c07e189ce316258da0a8177b2c42fa028f4aaf418245fbda
-  data.tar.gz: f9d629342ffead4be91ce5728d2048a56b9de3da660df32b962d549756391ca34758edf7e1392e3aefbd117d185ff179cda085e59f4d5ad4b20e802fbdcbf060
+  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/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/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.rc14'
+  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'

metadata

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