labimotion 2.2.0.rc8 → 2.2.0.rc10

data/README.md

@@ -0,0 +1,68 @@
+# LabIMotion [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3755759.svg)](https://doi.org/10.5281/zenodo.8305411)
+
+LabIMotion is a software that offers the flexibility to design new modules tailored to the specific needs of the scientists.
+Generic elements, segments, and datasets are organized using Components, which are introduced as layers and fields. Each generic element, segment, or dataset can include multiple layers, with the potential for multiple fields within each layer. This hierarchical structure enables a flexible and comprehensive organization of data and information.
+
+
+
+![Design Principles](https://www.chemotion.net/assets/images/generic_feature_outline-a58eee8e02ca7247e54f7ad17ee2c102.png)
+
+
+## Version 1.0.18 of LabIMotion, featuring:
+
+* Generic Designer
+* Workflow of Generic Element
+* Repetitation of layers
+* Drag Element to Element
+* Dataset Metadata
+* LabIMotion Template Hub Synchronization [**[LabIMotion Template Hub]**]
+
+---
+
+This repository contains a backend service for the LabIMotion. It is written in **[Ruby]**.
+
+### Community
+
+  * [GitHub discussions](https://github.com/labimotion/labimotion/discussions)
+  
+### Code
+
+  * [GitHub code](https://github.com/labimotion/labimotion) and [bug tracker](https://github.com/labimotion/labimotion/issues)
+
+---
+
+
+## Documentation
+
+Documentation for users **⸢ [Documentation] ⸥**
+
+Documentation for developers **⸢ [Technical Documentation] ⸥**
+
+---
+
+## License
+
+Code released under the [AGPL-3.0 License]([https://www.gnu.org/licenses/agpl-3.0.txt](https://www.gnu.org/licenses/agpl-3.0.txt)).
+
+---
+
+## Acknowledgments
+
+This project has been funded by the **[DFG]**.
+
+[![DFG Logo]][DFG]
+
+
+Funded by the [Deutsche Forschungsgemeinschaft (DFG, German Research Foundation)](https://www.dfg.de/) under the [National Research Data Infrastructure – NFDI4Chem](https://nfdi4chem.de/) – Projektnummer **441958208** since 2020.
+
+
+
+<!----------------------------------------------------------------------------->
+[Documentation]: https://www.chemotion.net/docs/labimotion/
+[Technical Documentation]: https://www.rubydoc.info/gems/labimotion
+[DFG]: https://www.dfg.de/en/
+[DFG Logo]: https://www.dfg.de/zentralablage/bilder/service/logos_corporate_design/logo_negativ_267.png
+[Nicole Jung]: mailto:nicole.jung@kit.edu
+[Karlsruhe Institute of Technology]: https://www.kit.edu/english/
+[Ruby]: https://www.ruby-lang.org/
+[LabIMotion Template Hub]: https://www.chemotion-repository.net/home/genericHub

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)
           []

data/lib/labimotion/apis/labimotion_api.rb

@@ -12,5 +12,9 @@ module Labimotion
     mount Labimotion::LabimotionHubAPI
     mount Labimotion::StandardLayerAPI
     mount Labimotion::VocabularyAPI
+    mount Labimotion::UserAPI
+    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