labimotion 2.2.0.rc8 → 2.2.0.rc9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2342f8963ebba3b102957a308070a94ecb87e49ba05641b22c32b5d49a0ff0a6
-  data.tar.gz: 4ed1239dc5c9ed49c97c453abe0cff9c9656b54fd1faaaf5607f9ad9fc75a148
+  metadata.gz: fde410e148abdf50036fd9146e2faea1ccd5078f7c93ec99dbd1c3fa6680ee96
+  data.tar.gz: 3a63d545e4b1c9da579e582f956ead5e2d204c4f9078f47803322a4831ce8b50
 SHA512:
-  metadata.gz: 53c17583059e150dd89e8308062ab4b658def233285940c0e0dbcc0aee9d3e15ce7d2fd7a05619f5416a4d5fd0a6507967a0a50b6b5f1894792864ee628bd682
-  data.tar.gz: 267f0cf9ac7c535642d8bff93fafa66cc5661d6cd7d820cf473ab41540f8b4004c9c1403f2d208187e4c199c612bf65171b6b9159fba2a49140a0b052095d16a
+  metadata.gz: 1c2cd08a3c54a452994ab180b014e53545ade8ff6ebf65d19a06a23fe47770b7e27bb2c4e04e8c7c05d4a3ab45875240f5cdac29e3ae1e64f49281ea3d9a6bb3
+  data.tar.gz: 318fa9de8609f13f1074620e09aa24d62ad135d956e5415dfa582d262787897dbb70d119144a80227c4b567138fd69e871196dba072b6fb3e9eb5276ae0239f9

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class ElementVariationAPI < Grape::API
+    rescue_from ActiveRecord::RecordNotFound do
+      error!('404 Element not found', 404)
+    end
+
+    resource :element_variations do
+      params do
+        requires :element_id, type: Integer, desc: 'Generic element id'
+      end
+      route_param :element_id do
+        before do
+          @element = Labimotion::Element.find(params[:element_id])
+          error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, @element).read?
+        end
+
+        desc 'Return element variations for a generic element'
+        get do
+          record = Labimotion::ElementVariation.find_or_initialize_by(element_id: @element.id)
+          present record, with: Labimotion::ElementVariationEntity, root: 'element_variation'
+        end
+
+        desc 'Upsert element variations for a generic element'
+        params do
+          requires :variations, type: Hash, desc: 'Variations keyed by row uuid'
+          optional :layout, type: Hash, desc: 'Column layout (selected/order/units/rowOrder)'
+        end
+        put do
+          error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, @element).update?
+
+          record = Labimotion::ElementVariation.find_or_initialize_by(element_id: @element.id)
+          record.variations = params[:variations] || {}
+          if params.key?(:layout) && record.class.column_names.include?('layout')
+            record.layout = params[:layout] || {}
+          end
+          record.save!
+
+          present record, with: Labimotion::ElementVariationEntity, root: 'element_variation'
+        end
+      end
+    end
+  end
+end

data/lib/labimotion/apis/generic_element_api.rb

@@ -179,10 +179,11 @@ module Labimotion
       end
 
       namespace :klass_revisions do
-        desc 'list Generic Element Revisions'
+        desc 'list Generic Klass Revisions'
         params do
           requires :id, type: Integer, desc: 'Generic Element Klass Id'
           requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+          optional :limit, type: Integer, default: 10, desc: 'Max revisions returned'
         end
         get do
           list = list_klass_revisions(params)
@@ -197,6 +198,7 @@ module Labimotion
         desc 'list Generic Element Revisions'
         params do
           requires :id, type: Integer, desc: 'Generic Element Id'
+          optional :limit, type: Integer, default: 10, desc: 'Max revisions returned'
         end
         get do
           list = element_revisions(params)
@@ -241,14 +243,15 @@ module Labimotion
       end
 
       namespace :segment_revisions do
-        desc 'list Generic Element Revisions'
+        desc 'list Generic Segment Revisions'
         params do
           optional :id, type: Integer, desc: 'Generic Element Id'
+          optional :limit, type: Integer, default: 10, desc: 'Max revisions returned'
         end
         get do
           klass = Labimotion::Segment.find(params[:id])
           list = klass.segments_revisions unless klass.nil?
-          present list&.order(created_at: :desc)&.limit(10), with: Labimotion::SegmentRevisionEntity, root: 'revisions'
+          present list&.order(created_at: :desc)&.limit(params[:limit]), with: Labimotion::SegmentRevisionEntity, root: 'revisions'
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)
           []
@@ -429,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

@@ -12,5 +12,8 @@ module Labimotion
     mount Labimotion::LabimotionHubAPI
     mount Labimotion::StandardLayerAPI
     mount Labimotion::VocabularyAPI
+    mount Labimotion::MttAPI
+    mount Labimotion::DoseRespRequestAPI
+    mount Labimotion::ElementVariationAPI
   end
 end

data/lib/labimotion/apis/mtt_api.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'labimotion/version'
+require 'labimotion/libs/export_element'
+require 'labimotion/helpers/mtt_helpers'
+require 'labimotion/models/dose_resp_output'
+
+module Labimotion
+  # Generic Element API
+  class MttAPI < Grape::API
+    helpers Labimotion::ParamHelpers
+    helpers Labimotion::MttHelpers
+
+    namespace :public do
+      resource :mtt_apps do
+        route_param :token do
+          desc 'Download data from MTT app (GET endpoint)'
+          get do
+            download_json_to_external_app
+          end
+
+          desc 'Upload modified data from MTT app (POST endpoint)'
+          post do
+            upload_json_from_external_app
+          end
+        end
+      end
+    end
+
+    resource :mtt do
+      namespace :requests do
+        desc 'Get MTT requests for current user'
+        get do
+          # Get all requests created by current user
+          requests = Labimotion::DoseRespRequest
+                     .includes(:dose_resp_outputs)
+                     .where(created_by: current_user.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
+        end
+
+        desc 'Delete one or multiple MTT requests'
+        params do
+          requires :ids, type: Array[Integer], desc: 'Array of request IDs to delete'
+        end
+        delete do
+          # Find requests belonging to current user
+          requests = Labimotion::DoseRespRequest.where(
+            id: params[:ids],
+            created_by: current_user.id
+          )
+
+          if requests.empty?
+            error!('No requests found or unauthorized', 404)
+          end
+
+          deleted_count = requests.count
+          requests.destroy_all
+
+          {
+            success: true,
+            message: "Successfully deleted #{deleted_count} request(s)",
+            deleted_count: deleted_count
+          }
+        rescue StandardError => e
+          error!("Error deleting requests: #{e.message}", 500)
+        end
+
+        desc 'Update MTT request'
+        params do
+          requires :id, type: Integer, desc: 'Request ID'
+          optional :state, type: Integer, desc: 'State (-1: error, 0: initial, 1: processing, 2: completed)', values: [-1, 0, 1, 2]
+          optional :resp_message, type: String, desc: 'Response message'
+          optional :wellplates_metadata, type: Hash, desc: 'Wellplates metadata'
+          optional :input_metadata, type: Hash, desc: 'Input metadata'
+          optional :revoked, type: Boolean, desc: 'Revoke access token'
+        end
+        patch ':id' do
+          # Find request belonging to current user
+          request = Labimotion::DoseRespRequest.find_by(
+            id: params[:id],
+            created_by: current_user.id
+          )
+
+          error!('Request not found or unauthorized', 404) unless request
+
+          # Prepare update attributes
+          update_attrs = {}
+          update_attrs[:state] = params[:state] if params.key?(:state)
+          update_attrs[:resp_message] = params[:resp_message] if params.key?(:resp_message)
+          update_attrs[:wellplates_metadata] = params[:wellplates_metadata] if params.key?(:wellplates_metadata)
+          update_attrs[:input_metadata] = params[:input_metadata] if params.key?(:input_metadata)
+          update_attrs[:revoked_at] = params[:revoked] ? Time.current : nil if params.key?(:revoked)
+
+          if request.update(update_attrs)
+            {
+              success: true,
+              message: 'Request updated successfully',
+              request: {
+                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,
+                resp_message: request.resp_message,
+                revoked: request.revoked?,
+                updated_at: request.updated_at
+              }
+            }
+          else
+            error!("Validation error: #{request.errors.full_messages.join(', ')}", 422)
+          end
+        rescue ActiveRecord::RecordNotFound
+          error!('Request not found', 404)
+        rescue StandardError => e
+          error!("Error updating request: #{e.message}", 500)
+        end
+      end
+
+      namespace :outputs do
+        desc 'Delete one or multiple MTT outputs'
+        params do
+          requires :ids, type: Array[Integer], desc: 'Array of output IDs to delete'
+        end
+        delete do
+          # Find outputs where the parent request belongs to current user
+          outputs = Labimotion::DoseRespOutput
+                    .joins(:dose_resp_request)
+                    .where(
+                      id: params[:ids],
+                      dose_resp_requests: { created_by: current_user.id }
+                    )
+
+          if outputs.empty?
+            error!('No outputs found or unauthorized', 404)
+          end
+
+          deleted_count = outputs.count
+          outputs.destroy_all
+
+          {
+            success: true,
+            message: "Successfully deleted #{deleted_count} output(s)",
+            deleted_count: deleted_count
+          }
+        rescue StandardError => e
+          error!("Error deleting outputs: #{e.message}", 500)
+        end
+      end
+
+      namespace :create_mtt_request do
+        desc 'Create MTT assay request'
+        params do
+          use :create_mtt_request_params
+        end
+        post do
+          # 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?
+
+          wellplates = Wellplate.where(id: params[:wellplate_ids])
+          error!('No wellplates found', 404) if wellplates.empty?
+
+          # Generate wellplates metadata
+          wellplates_metadata = generate_wellplates_metadata(wellplates)
+
+          # Create DoseRespRequest record with token
+          dose_resp_request = Labimotion::DoseRespRequest.create!(
+            element_id: element.id,
+            wellplates_metadata: { wellplates: wellplates_metadata },
+            input_metadata: {
+              wellplate_ids: params[:wellplate_ids],
+              element_id: element.id,
+              element_name: element.name,
+              created_at: Time.current
+            },
+            state: Labimotion::DoseRespRequest::STATE_INITIAL,
+            created_by: current_user&.id,
+            expires_at: TPA_EXPIRATION.from_now
+          )
+
+          # Generate external app URL with token
+          token_uri = token_url(dose_resp_request)
+          external_app_url = get_external_app_url
+
+          # Format: "#{@app.url}?url=#{CGI.escape(token_uri)}&type=ThirdPartyApp"
+          "#{external_app_url}?method=DoseResponse&url=#{CGI.escape(token_uri)}"
+        rescue ActiveRecord::RecordInvalid => e
+          error!("Validation error: #{e.message}", 422)
+        rescue ActiveRecord::RecordNotFound => e
+          error!("Not found: #{e.message}", 404)
+        rescue StandardError => e
+          error!("Error: #{e.message}", 500)
+        end
+      end
+    end
+  end
+end

data/lib/labimotion/entities/element_entity.rb

@@ -23,6 +23,7 @@ module Labimotion
       expose! :uuid
       expose! :user_labels
       expose! :preview_attachment # align with eln change
+      expose! :variations_count
     end
 
     with_options(anonymize_below: 10) do

data/lib/labimotion/entities/element_variation_entity.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'labimotion/entities/application_entity'
+
+module Labimotion
+  class ElementVariationEntity < Labimotion::ApplicationEntity
+    expose :id
+    expose :element_id, as: :elementId
+    expose :variations
+    expose :layout
+
+    def variations
+      rows = object.variations_hash
+      rows.transform_values do |row|
+        next row unless row.is_a?(Hash)
+
+        row.symbolize_keys.slice(:uuid, :name, :properties, :metadata, :segments).tap do |slim|
+          slim[:properties] = (slim[:properties] || {})
+          slim[:metadata] = (slim[:metadata] || {}).slice('notes', 'analyses', 'group', :notes, :analyses, :group)
+          slim[:segments] = (slim[:segments] || {})
+        end
+      end
+    end
+
+    def layout
+      object.layout_hash
+    end
+  end
+end