labimotion 2.2.0.rc1 → 2.2.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4397eed28e8f2c6f0e21e022191d842dbb7a42000a2efe72731a89ab8bf9e77b
-  data.tar.gz: 3ae429541da0f787d6d0f544307b5acfbf3e922d83c7fc7cd27e47738eb5880e
+  metadata.gz: cb971ee12b9b92fde6ca26d8f0a0bd985394818a288737a2f81cb59aba287e2f
+  data.tar.gz: 2c46c6d66d83862000fbf793ecfac276ce8a3c2a227fb10262645bc30f849c5f
 SHA512:
-  metadata.gz: 12a5d77d600daaf1a45640ab5ff7d253a608cd683fac28a5286019a7990e85cb7c1f0c957240fab625d3dbb703196dcb918b652bcc86457c6ac88cc085990ea0
-  data.tar.gz: 28453642570e3e177c0c2684590cdb715016c4043645d9f2e097eca0a4f41e9e3ff30564df8a0b7d5800bfb36a2fd224aa40cb91a107a2bc53adddc1db133070
+  metadata.gz: afe6d72ca32cf16a795f71f9aee7b757f1cdd7cb6b7703885c6d24912f1f73a800da0455183fc1cc9944511d2f090c4c99ee8933f83aea02e81b11b5b982bd17
+  data.tar.gz: 42f7025b7f47dab2554ab2b39992e978ff9c3e63959f0fe5342f5c4c09bb64b2a6525c9d2355eb4f7b77a6a9881c4a6ce594997b3ff773fcefea64dcb7f9162f

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

@@ -474,7 +474,7 @@ module Labimotion
               detail_levels: ElementDetailLevelCalculator.new(user: current_user, element: element).detail_levels,
               policy: @element_policy
             ),
-            attachments: attach_thumbnail(element&.attachments)
+            attachments: Entities::AttachmentEntity.represent(element&.attachments)
           }
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)
@@ -517,7 +517,7 @@ module Labimotion
                 element,
                 detail_levels: ElementDetailLevelCalculator.new(user: current_user, element: element).detail_levels,
               ),
-              attachments: attach_thumbnail(element&.attachments),
+              attachments: Entities::AttachmentEntity.represent(element&.attachments),
             }
           rescue StandardError => e
             Labimotion.log_exception(e, current_user)

data/lib/labimotion/apis/labimotion_api.rb

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

data/lib/labimotion/apis/mtt_api.rb

@@ -0,0 +1,236 @@
+# 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
+        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/collection/import.rb

@@ -69,7 +69,7 @@ module Labimotion
 
           dataset = Labimotion::Dataset.create!(
             fields.slice(
-              'properties', 'properties_release'
+              'properties', 'properties_release', 'metadata'
             ).merge(
               ## created_by: current_user_id,
               element: element,
@@ -112,7 +112,7 @@ module Labimotion
 
         segment = Labimotion::Segment.create!(
           fields.slice(
-            'properties', 'properties_release'
+            'properties', 'properties_release', 'metadata'
           ).merge(
             created_by: current_user_id,
             element: element,
@@ -149,7 +149,7 @@ module Labimotion
 
         element = Labimotion::Element.create!(
           fields.slice(
-            'name', 'properties', 'properties_release'
+            'name', 'properties', 'properties_release', 'metadata'
           ).merge(
             created_by: current_user_id,
             element_klass: element_klass,

data/lib/labimotion/helpers/element_helpers.rb

@@ -82,7 +82,8 @@ module Labimotion
         klass_uuid: klass[:uuid],
         properties: properties,
         properties_release: params[:properties_release],
-        created_by: current_user.id,
+        metadata: params[:metadata] || {},
+        created_by: current_user.id
       }
       element = Labimotion::Element.new(attributes)
 
@@ -116,7 +117,8 @@ module Labimotion
       params.delete(:user_labels)
       attributes = declared(params.except(:segments), include_missing: false)
       properties['pkg'] = Labimotion::Utils.pkg(properties['pkg'])
-      if element.klass_uuid != properties['klass_uuid'] || element.properties != properties || element.name != params[:name]
+      metadata = params[:metadata] || element.metadata || {}
+      if element.klass_uuid != properties['klass_uuid'] || element.properties != properties || element.name != params[:name] || element.metadata != metadata
         properties['klass'] = 'Element'
         uuid = SecureRandom.uuid
         properties['uuid'] = uuid
@@ -128,6 +130,7 @@ module Labimotion
         attributes['properties']['uuid'] = uuid
         attributes['uuid'] = uuid
         attributes['klass_uuid'] = properties['klass_uuid']
+        attributes['metadata'] = metadata
         attributes['updated_at'] = Time.current
         element.update_columns(attributes)
       end

data/lib/labimotion/helpers/mtt_helpers.rb

@@ -0,0 +1,403 @@
+# frozen_string_literal: true
+
+require 'grape'
+require 'net/http'
+require 'uri'
+require 'zip'
+
+module Labimotion
+  ## MTT Helpers
+  module MttHelpers
+    extend Grape::API::Helpers
+
+    TPA_EXPIRATION = 72.hours
+
+    def token_url(dose_resp_request)
+      # Build the callback URL with token in path
+      api_base_url = ENV['PUBLIC_URL'] || 'http://172.28.156.100:3000'
+      callback_path = "/api/v1/public/mtt_apps/#{dose_resp_request.access_token}"
+      callback_url = "#{api_base_url}#{callback_path}"
+
+      callback_url
+    end
+
+    def get_external_app_url
+      ENV['MTT_EXTERNAL_APP_URL'] || 'http://localhost:4050'
+    end
+
+    def validate_token(token)
+      # Find the request by access token
+      request = Labimotion::DoseRespRequest.find_by(access_token: token)
+      error!('Token not found', 404) unless request
+
+      # Check expiration
+      error!('Token expired', 403) if request.expired?
+
+      # Check revocation
+      error!('Token revoked', 403) if request.revoked?
+
+      request
+    end
+
+    def validate_user_access(dose_resp_request)
+      # Get element and user
+      element = dose_resp_request.element
+      error!('Element not found', 404) unless element
+
+      user = dose_resp_request.creator
+      error!('User not found', 404) unless user
+
+      # Check user has update permission on element using ElementPolicy
+      policy = ElementPolicy.new(user, element)
+      error!('Unauthorized', 403) unless policy.update?
+
+      { element: element, user: user }
+    end
+
+    def download_json_to_external_app
+      # Get token from route params
+      token = params[:token]
+      dose_resp_request = validate_token(token)
+
+      # Validate user access
+      validate_user_access(dose_resp_request)
+
+      # Track access and update state
+      # dose_resp_request.track_access!
+      dose_resp_request.mark_processing! if dose_resp_request.state == Labimotion::DoseRespRequest::STATE_INITIAL
+      # Return wellplates metadata as JSON
+      # Access the wellplates array from the metadata structure
+      wellplates_data = dose_resp_request.wellplates_metadata&.dig('wellplates') ||
+                        dose_resp_request.wellplates_metadata&.dig(:wellplates) ||
+                        []
+
+      response_data = {
+        id: dose_resp_request.id.to_s,
+        request_id: dose_resp_request.request_id,
+        wellplates: wellplates_data
+      }
+
+      status 200
+      response_data
+    rescue => e
+      error!("Error: #{e.message}", 500)
+    end
+
+    def upload_json_from_external_app
+      # Get token from route params
+      token = params[:token]
+      dose_resp_request = validate_token(token)
+
+      # Validate user access
+      access_info = validate_user_access(dose_resp_request)
+      user = access_info[:user]
+      element = access_info[:element]
+      # Handle file upload
+      file_param = params['file'] || params[:file]
+      error!('No file uploaded', 400) unless file_param && file_param.is_a?(Hash) && file_param['tempfile']
+
+      tempfile = file_param['tempfile']
+      filename = file_param['filename'] || 'upload'
+      # Check if it's a zip file
+      if filename.end_with?('.zip')
+        # Process zip file
+        wellplates_data, csv_data = process_zip_file(tempfile)
+
+        error!('Missing JSON data in zip file', 400) unless wellplates_data
+
+        # Create analysis container and dataset with CSV if present
+        # if csv_data
+        #   create_analysis_with_csv(element, user, csv_data, dose_resp_request, wellplates_data)
+        # end
+      # else
+      #   # Handle single JSON file
+      #   file_content = tempfile.read
+      #   tempfile.rewind
+      #   json_data = JSON.parse(file_content).with_indifferent_access
+      #   wellplates_data = json_data[:Output]
+
+      #   error!('Missing wellplates data', 400) unless wellplates_data
+      end
+
+      dose_resp_request.track_access!
+
+      # Save output data to dose_resp_outputs table
+      output = dose_resp_request.dose_resp_outputs.create!(
+        output_data: { Output: wellplates_data }
+      )
+      if csv_data
+        create_analysis_with_csv(element, user, csv_data, dose_resp_request, output)
+      end
+
+      dose_resp_request.update!(
+        wellplates_metadata: { wellplates: wellplates_data },
+        resp_message: 'Data updated successfully'
+      )
+
+      # Mark as completed
+      dose_resp_request.mark_completed!
+
+      status 200
+      {
+        success: true,
+        message: 'Data updated successfully',
+        request_id: dose_resp_request.id
+      }
+    rescue JSON::ParserError => e
+      error!("Invalid JSON: #{e.message}", 400)
+    rescue ActiveRecord::RecordInvalid => e
+      dose_resp_request.mark_error!(e.message) if dose_resp_request
+      error!("Validation error: #{e.message}", 422)
+    rescue => e
+      dose_resp_request.mark_error!(e.message) if dose_resp_request
+      error!("Error: #{e.message}", 500)
+    end
+
+    def process_zip_file(tempfile)
+      wellplates_data = nil
+      csv_data = nil
+
+      Zip::File.open(tempfile.path) do |zip_file|
+        zip_file.each do |entry|
+          if entry.name.end_with?('.json')
+            # Read JSON file
+            json_content = entry.get_input_stream.read
+            json_data = JSON.parse(json_content).with_indifferent_access
+            wellplates_data = json_data[:Output]
+          elsif entry.name.end_with?('.xls', '.xlsx', '.csv')
+            # Read CSV/Excel file - extract just the basename without path
+            csv_content = entry.get_input_stream.read
+            csv_data = {
+              filename: File.basename(entry.name),
+              content: csv_content
+            }
+          end
+        end
+      end
+
+      [wellplates_data, csv_data]
+    end
+
+    def create_analysis_with_csv(element, user, csv_data, dose_resp_request, output)
+      analysis, dataset = create_analysis_with_dataset(
+        element: element,
+        analysis_name: "MTT Analysis #{dose_resp_request.request_id}-#{output&.id}",
+        dataset_name: 'new',
+        analysis_attributes: {}
+      )
+
+      # Determine content type based on file extension
+      content_type = case File.extname(csv_data[:filename]).downcase
+                     when '.xlsx'
+                       'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+                     when '.xls'
+                       'application/vnd.ms-excel'
+                     when '.csv'
+                       'text/csv'
+                     else
+                       'application/octet-stream'
+                     end
+
+      # Create a temporary file for the attachment
+      temp_file = Tempfile.new([File.basename(csv_data[:filename], '.*'), File.extname(csv_data[:filename])])
+      begin
+        temp_file.binmode
+        temp_file.write(csv_data[:content])
+        temp_file.rewind
+
+        # Create attachment for CSV/Excel file
+        attachment = Attachment.new(
+          filename: csv_data[:filename],
+          file_path: temp_file.path,
+          created_by: user.id,
+          created_for: user.id,
+          attachable_type: 'Container',
+          attachable_id: dataset.id,
+          content_type: content_type
+        )
+        attachment.save! if attachment.valid?
+
+        { analysis: analysis, dataset: dataset, attachment: attachment }
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+    end
+
+    def create_analysis_with_dataset(
+      element:,
+      analysis_name: 'New Analysis',
+      dataset_name: 'New Dataset',
+      analysis_attributes: {}
+    )
+      # Ensure the element has a root container
+      ensure_root_container(element)
+
+      # Get or create the analyses container
+      analyses_container = element.container.children.find_or_create_by(container_type: 'analyses')
+
+      # Prepare default extended_metadata for analysis
+      default_metadata = {
+        'content' => '{"ops":[{"insert":""}]}',
+        'report' => true
+      }
+      extended_metadata = default_metadata.merge(analysis_attributes[:extended_metadata] || {})
+
+      # Create the analysis container
+      analysis_container = analyses_container.children.create(
+        container_type: 'analysis',
+        name: analysis_name,
+        description: analysis_attributes[:description] || '',
+        extended_metadata: extended_metadata
+      )
+
+      # Create the dataset container nested under the analysis
+      dataset_container = analysis_container.children.create(
+        container_type: 'dataset',
+        name: dataset_name,
+        description: '',
+        extended_metadata: {}
+      )
+
+      [analysis_container, dataset_container]
+    end
+
+    def ensure_root_container(element)
+      return if element.container.present?
+
+      element.container = Container.create_root_container
+    end
+    # def send_mtt_request(current_user, params)
+
+    #   token_uri = token_url(current_user, params)
+
+
+    #   uri = URI.parse(api_url)
+    #   http = Net::HTTP.new(uri.host, uri.port)
+    #   http.use_ssl = (uri.scheme == 'https')
+    #   http.read_timeout = 30
+
+    #   # Ensure path is not empty, default to '/' if needed
+    #   path = uri.path.empty? ? '/' : uri.path
+    #   request = Net::HTTP::Post.new(path, { 'Content-Type' => 'application/json' })
+    #   request.body = json_data.to_json
+
+    #   response = http.request(request)
+
+    #   {
+    #     success: response.is_a?(Net::HTTPSuccess),
+    #     status: response.code,
+    #     body: (JSON.parse(response.body) rescue response.body),
+    #     message: response.message
+    #   }
+    # rescue StandardError => e
+    #   {
+    #     success: false,
+    #     error: e.message,
+    #     backtrace: e.backtrace.first(5)
+    #   }
+    # end
+
+    def extract_readout_titles(wellplate)
+      # Extract readout titles from wellplate
+      if wellplate.respond_to?(:readout_titles)
+        titles = wellplate.readout_titles
+        return titles if titles.is_a?(Array)
+        return JSON.parse(titles) if titles.is_a?(String)
+      end
+      []
+    end
+
+    def extract_wells(wellplate)
+      # Extract wells data from wellplate
+      wells = wellplate.wells || []
+      wells.map do |well|
+        # Position might be stored as a hash or separate fields
+        position = if well.respond_to?(:position) && well.position.is_a?(Hash)
+                     well.position
+                   elsif well.respond_to?(:position_x)
+                     { x: well.position_x, y: well.position_y }
+                   else
+                     { x: 0, y: 0 }
+                   end
+
+        well_data = {
+          id: well.id,
+          position: position
+        }
+
+        # Only include readouts if they have values
+        readouts = extract_readouts(well)
+        well_data[:readouts] = readouts if readouts.present?
+
+        # Only include sample if it exists
+        sample = extract_sample(well)
+        well_data[:sample] = sample if sample.present?
+
+        well_data
+      end
+    end
+
+    def extract_readouts(well)
+      # Extract readouts from well
+      # Readouts are typically stored as JSON data in the well
+      readouts = if well.respond_to?(:readouts) && well.readouts.is_a?(Array)
+                   well.readouts
+                 elsif well.respond_to?(:readouts) && well.readouts.is_a?(String)
+                   JSON.parse(well.readouts) rescue []
+                 elsif well.respond_to?(:readouts) && well.readouts.is_a?(Hash)
+                   well.readouts.values rescue []
+                 else
+                   []
+                 end
+
+      # Filter out empty readouts (both unit and value are blank)
+      readouts.select do |readout|
+        readout.is_a?(Hash) &&
+        (readout['unit'].to_s.present? || readout['value'].to_s.present? ||
+         readout[:unit].to_s.present? || readout[:value].to_s.present?)
+      end
+    end
+
+    def extract_sample(well)
+      # Extract sample information from well
+      if well.respond_to?(:sample) && well.sample.present?
+        sample = well.sample
+        return {
+          id: sample.id,
+          short_label: sample.short_label,
+          conc: sample.try(:molarity_value) || 0
+        }
+      end
+      nil
+    end
+
+    def generate_wellplates_metadata(wellplates)
+      wellplates.map do |wellplate|
+        {
+          id: wellplate.id.to_s,
+          readoutTitles: extract_readout_titles(wellplate),
+          wells: extract_wells(wellplate)
+        }
+      end
+    end
+
+
+    def generate_json_data(wellplates)
+      # # Generate wellplates metadata
+      wellplates_metadata = generate_wellplates_metadata(wellplates)
+
+      # Generate JSON structure
+      json_data = {
+        id: element.id.to_s,
+        request_id: dose_resp_request.id.to_s,
+        wellplates: wellplates_metadata
+      }
+      # Save to JSON file
+      filename = "mtt_request_#{element.id}_#{dose_resp_request.id}.json"
+      filepath = Rails.root.join('tmp', filename)
+      File.write(filepath, JSON.pretty_generate(json_data))
+      json_data
+    end
+  end
+end

data/lib/labimotion/helpers/param_helpers.rb

@@ -13,6 +13,7 @@ module Labimotion
       optional :desc, type: String, desc: 'Klass desc'
       optional :klass_prefix, type: String, desc: 'Klass klass_prefix'
       optional :icon_name, type: String, desc: 'Klass icon_name'
+      optional :metadata, type: Hash, desc: 'Klass metadata'
       requires :properties_template, type: Hash, desc: 'Klass template'
       optional :properties_release, type: Hash, desc: 'Klass release'
       optional :released_at, type: DateTime, desc: 'Klass released_at'
@@ -29,6 +30,7 @@ module Labimotion
       requires :klass_prefix, type: String, desc: 'Element Klass Short Label Prefix'
       optional :icon_name, type: String, desc: 'Element Klass Icon Name'
       optional :desc, type: String, desc: 'Element Klass Desc'
+      optional :metadata, type: Hash, desc: 'Element Klass metadata'
       optional :properties_template, type: Hash, desc: 'Element Klass properties template'
     end
 
@@ -69,6 +71,7 @@ module Labimotion
     params :upload_segment_klass_params do
       requires :label, type: String, desc: 'Klass label'
       optional :desc, type: String, desc: 'Klass desc'
+      optional :metadata, type: Hash, desc: 'Klass metadata'
       requires :properties_template, type: Hash, desc: 'Klass template'
       optional :properties_release, type: Hash, desc: 'Klass release'
       optional :released_at, type: DateTime, desc: 'Klass released_at'
@@ -95,6 +98,7 @@ module Labimotion
       requires :element_klass, type: Integer, desc: 'Element Klass Id'
       optional :desc, type: String, desc: 'Segment Klass Desc'
       optional :place, type: String, desc: 'Segment Klass Place', default: '100'
+      optional :metadata, type: Hash, desc: 'Klass metadata'
       optional :properties_template, type: Hash, desc: 'Element Klass properties template'
     end
 
@@ -142,5 +146,11 @@ module Labimotion
       requires :layer_id, type: String, desc: 'layer identifier'
       requires :field_id, type: String, desc: 'field identifier'
     end
+
+
+    params :create_mtt_request_params do
+      requires :id, type: Integer, desc: 'Element ID'
+      requires :wellplate_ids, type: Array, desc: 'Selected Wellplates'
+    end
   end
 end

data/lib/labimotion/libs/converter.rb

@@ -222,7 +222,8 @@ module Labimotion
         element_id: cds.id,
         properties: props,
         properties_release: klass.properties_release,
-        klass_uuid: klass.uuid
+        klass_uuid: klass.uuid,
+        metadata: klass.metadata
       )
     end
 

data/lib/labimotion/libs/dataset_builder.rb

@@ -44,7 +44,8 @@ module Labimotion
         element_id: container.id,
         properties: props,
         properties_release: klass.properties_release,
-        klass_uuid: klass.uuid
+        klass_uuid: klass.uuid,
+        metadata: klass.metadata
       )
     end
 

data/lib/labimotion/models/concerns/datasetable.rb

@@ -29,6 +29,7 @@ module Labimotion
         properties: ods.properties,
         properties_release: ods.properties_release,
         klass_uuid: ods.klass_uuid,
+        metadata: ods.metadata || {}
       )
     end
 
@@ -49,8 +50,8 @@ module Labimotion
       props = Labimotion::VocabularyHandler.update_vocabularies(props, dataset_args[:current_user], dataset_args[:element])
 
       ds = Labimotion::Dataset.find_by(element_type: self.class.name, element_id: id)
-      if ds.present? && (ds.klass_uuid != klass.uuid || ds.properties != props)
-        ds.update!(properties_release: klass.properties_release, uuid: uuid, dataset_klass_id: dataset_klass_id, properties: props, klass_uuid: klass.uuid)
+      if ds.present? && (ds.klass_uuid != klass.uuid || ds.properties != props || ds.metadata != metadata)
+        ds.update!(properties_release: klass.properties_release, uuid: uuid, dataset_klass_id: dataset_klass_id, properties: props, klass_uuid: klass.uuid, metadata: metadata)
       end
       return if ds.present?
 

data/lib/labimotion/models/concerns/generic_klass_revisions.rb

@@ -9,7 +9,6 @@ module Labimotion
       before_save :check_identifier
     end
 
-
     def check_identifier
       self.identifier = identifier || SecureRandom.uuid if self.has_attribute?(:identifier)
     end
@@ -34,7 +33,7 @@ module Labimotion
         properties_release: properties_release,
         released_at: DateTime.now,
         updated_by: current_user&.id,
-        released_by: current_user&.id,
+        released_by: current_user&.id
       }
 
       self.update!(klass_attributes)
@@ -46,7 +45,7 @@ module Labimotion
         created_by: updated_by,
         properties_release: properties_release,
         released_at: released_at,
-        metadata: metadata
+        metadata: metadata || {}
       }
       attributes["#{self.class.name.underscore.split('/').last}_id"] = id
       "#{self.class.name}esRevision".constantize.create(attributes)

data/lib/labimotion/models/dose_resp_output.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class DoseRespOutput < ApplicationRecord
+    acts_as_paranoid
+    self.table_name = :dose_resp_outputs
+
+    # Associations
+    belongs_to :dose_resp_request, class_name: 'Labimotion::DoseRespRequest'
+
+    # Validations
+    validates :dose_resp_request, presence: true
+    validates :output_data, presence: true
+    validate :output_data_is_hash
+
+    # Scopes
+    scope :recent, -> { order(created_at: :desc) }
+
+    private
+
+    def output_data_is_hash
+      return if output_data.is_a?(Hash)
+
+      errors.add(:output_data, 'must be a Hash')
+    end
+  end
+end

data/lib/labimotion/models/dose_resp_request.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class DoseRespRequest < ApplicationRecord
+    acts_as_paranoid
+    self.table_name = :dose_resp_requests
+
+    # Token generation
+    has_secure_token :access_token
+
+    # Callbacks
+    before_create :generate_request_id
+
+    # Associations
+    belongs_to :element, class_name: 'Labimotion::Element'
+    belongs_to :creator, foreign_key: :created_by, class_name: 'User'
+    has_many :dose_resp_outputs, class_name: 'Labimotion::DoseRespOutput', dependent: :destroy
+
+    # Validations
+    validates :element, presence: true
+    validates :creator, presence: true
+    validates :expires_at, presence: true
+    validates :state, inclusion: { in: [-1, 0, 1, 2] }
+    validate :metadata_is_hash
+    validate :input_metadata_is_hash
+
+    # State constants
+    STATE_ERROR = -1
+    STATE_INITIAL = 0
+    STATE_PROCESSING = 1
+    STATE_COMPLETED = 2
+
+    # Scopes
+    scope :active, -> { where('expires_at > ?', Time.current).where(revoked_at: nil) }
+    scope :expired, -> { where('expires_at <= ?', Time.current) }
+    scope :revoked, -> { where.not(revoked_at: nil) }
+
+    # Instance methods
+    def expired?
+      expires_at.present? && expires_at < Time.current
+    end
+
+    def revoked?
+      revoked_at.present?
+    end
+
+    def active?
+      !expired? && !revoked?
+    end
+
+    def revoke!
+      update!(revoked_at: Time.current, state: STATE_ERROR)
+    end
+
+    def mark_processing!
+      update!(state: STATE_PROCESSING) if state == STATE_INITIAL
+    end
+
+    def mark_completed!
+      update!(state: STATE_COMPLETED)
+    end
+
+    def mark_error!(message = nil)
+      update!(state: STATE_ERROR, resp_message: message)
+    end
+
+    def track_access!
+      increment!(:access_count)
+      update_columns(
+        first_accessed_at: first_accessed_at || Time.current,
+        last_accessed_at: Time.current
+      )
+    end
+
+    private
+
+    def metadata_is_hash
+      return if wellplates_metadata.nil? || wellplates_metadata.is_a?(Hash)
+
+      errors.add(:wellplates_metadata, 'must be a hash')
+    end
+
+    def input_metadata_is_hash
+      return if input_metadata.nil? || input_metadata.is_a?(Hash)
+
+      errors.add(:input_metadata, 'must be a hash')
+    end
+
+    def generate_request_id
+      self.request_id = "MTT-#{Time.current.strftime('%Y%m%d-%H%M%S')}-#{SecureRandom.hex(3)}"
+    end
+  end
+end

data/lib/labimotion/version.rb

@@ -2,5 +2,5 @@
 
 ## Labimotion Version
 module Labimotion
-  VERSION = '2.2.0.rc1'
+  VERSION = '2.2.0.rc3'
 end

data/lib/labimotion.rb

@@ -27,6 +27,8 @@ module Labimotion
   autoload :ExporterAPI, 'labimotion/apis/exporter_api'
   autoload :StandardLayerAPI, 'labimotion/apis/standard_layer_api'
   autoload :VocabularyAPI, 'labimotion/apis/vocabulary_api'
+  autoload :MttAPI, 'labimotion/apis/mtt_api'
+  autoload :DoseRespRequestAPI, 'labimotion/apis/dose_resp_request_api'
 
   ######## Entities
   autoload :PropertiesEntity, 'labimotion/entities/properties_entity'
@@ -114,6 +116,8 @@ module Labimotion
   autoload :StdLayersRevision, 'labimotion/models/std_layers_revision'
 
   autoload :DeviceDescription, 'labimotion/models/device_description'
+  autoload :DoseRespRequest, 'labimotion/models/dose_resp_request'
+  autoload :DoseRespOutput, 'labimotion/models/dose_resp_output'
   autoload :Reaction, 'labimotion/models/reaction'
   autoload :ResearchPlan, 'labimotion/models/research_plan'
   autoload :Sample, 'labimotion/models/sample'
@@ -126,6 +130,6 @@ module Labimotion
   autoload :ElementFetchable, 'labimotion/models/concerns/element_fetchable'
   autoload :Segmentable, 'labimotion/models/concerns/segmentable'
   autoload :Datasetable, 'labimotion/models/concerns/datasetable'
-  autoload :AttachmentConverter, 'labimotion/models/concerns/attachment_converter.rb'
+  autoload :AttachmentConverter, 'labimotion/models/concerns/attachment_converter'
   autoload :LinkedProperties, 'labimotion/models/concerns/linked_properties'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.2.0.rc1
+  version: 2.2.0.rc3
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-12-25 00:00:00.000000000 Z
+date: 2026-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: caxlsx
@@ -55,12 +55,14 @@ extra_rdoc_files: []
 files:
 - lib/labimotion.rb
 - lib/labimotion/apis/converter_api.rb
+- lib/labimotion/apis/dose_resp_request_api.rb
 - lib/labimotion/apis/exporter_api.rb
 - lib/labimotion/apis/generic_dataset_api.rb
 - lib/labimotion/apis/generic_element_api.rb
 - lib/labimotion/apis/generic_klass_api.rb
 - lib/labimotion/apis/labimotion_api.rb
 - lib/labimotion/apis/labimotion_hub_api.rb
+- lib/labimotion/apis/mtt_api.rb
 - lib/labimotion/apis/segment_api.rb
 - lib/labimotion/apis/standard_api.rb
 - lib/labimotion/apis/standard_layer_api.rb
@@ -90,6 +92,7 @@ files:
 - lib/labimotion/helpers/element_helpers.rb
 - lib/labimotion/helpers/exporter_helpers.rb
 - lib/labimotion/helpers/generic_helpers.rb
+- lib/labimotion/helpers/mtt_helpers.rb
 - lib/labimotion/helpers/param_helpers.rb
 - lib/labimotion/helpers/repository_helpers.rb
 - lib/labimotion/helpers/sample_association_helpers.rb
@@ -130,6 +133,8 @@ files:
 - lib/labimotion/models/dataset_klasses_revision.rb
 - lib/labimotion/models/datasets_revision.rb
 - lib/labimotion/models/device_description.rb
+- lib/labimotion/models/dose_resp_output.rb
+- lib/labimotion/models/dose_resp_request.rb
 - lib/labimotion/models/element.rb
 - lib/labimotion/models/element_klass.rb
 - lib/labimotion/models/element_klasses_revision.rb