feat: element vessel api and UI

app/api/api.rb

@@ -138,7 +138,7 @@ def to_json_camel_case(val)
 
   TARGET = Rails.env.production? ? 'https://www.chemotion-repository.net/' : 'http://localhost:3000/'
 
-  ELEMENTS = %w[research_plan screen wellplate reaction sample cell_line].freeze
+  ELEMENTS = %w[research_plan screen wellplate reaction sample cell_line vessel].freeze
 
   ELEMENT_CLASS = {
     'research_plan' => ResearchPlan,
@@ -147,6 +147,7 @@ def to_json_camel_case(val)
     'reaction' => Reaction,
     'sample' => Sample,
     'cell_line' => CelllineSample,
+    'vessel' => Vessel,
   }.freeze
 
   mount Chemotion::LiteratureAPI
@@ -203,6 +204,7 @@ def to_json_camel_case(val)
   mount Chemotion::AdminDeviceAPI
   mount Chemotion::AdminDeviceMetadataAPI
   mount Chemotion::ChemicalAPI
+  mount Chemotion::VesselAPI
 
   if Rails.env.development?
     add_swagger_documentation(info: {

app/api/chemotion/collection_api.rb

@@ -193,6 +193,9 @@ class CollectionAPI < Grape::API
             optional :cell_line, type: Hash do
               use :ui_state_params
             end
+            optional :vessel, type: Hash do
+              use :ui_state_params
+            end
           end
           requires :collection_attributes, type: Hash do
             requires :permission_level, type: Integer
@@ -221,6 +224,9 @@ class CollectionAPI < Grape::API
           cell_lines = CelllineSample.by_collection_id(@cid)
                                      .by_ui_state(params[:elements_filter][:cell_line])
                                      .for_user_n_groups(user_ids)
+          vessels = Vessel.by_collection_id(@cid)
+                                     .by_ui_state(params[:elements_filter][:vessel])
+                                     .for_user_n_groups(user_ids)
           elements = {}
           Labimotion::ElementKlass.find_each do |klass|
             elements[klass.name] = Labimotion::Element.by_collection_id(@cid).by_ui_state(params[:elements_filter][klass.name]).for_user_n_groups(user_ids)
@@ -237,6 +243,7 @@ class CollectionAPI < Grape::API
           share_screens = ElementsPolicy.new(current_user, screens).share?
           share_research_plans = ElementsPolicy.new(current_user, research_plans).share?
           share_cell_lines = ElementsPolicy.new(current_user, cell_lines).share?
+          share_vessels = ElementsPolicy.new(current_user, vessels).share?
           share_elements = !(elements&.length > 0)
           elements.each do |k, v|
             share_elements = ElementsPolicy.new(current_user, v).share?
@@ -249,6 +256,7 @@ class CollectionAPI < Grape::API
                             share_screens &&
                             share_research_plans &&
                             share_cell_lines &&
+                            share_vessels &&
                             share_elements
           error!('401 Unauthorized', 401) if (!sharing_allowed || is_top_secret)
 
@@ -258,6 +266,7 @@ class CollectionAPI < Grape::API
           @screen_ids = screens.pluck(:id)
           @research_plan_ids = research_plans.pluck(:id)
           @cell_line_ids = cell_lines.pluck(:id)
+          @vessel_ids = vessels.pluck(:id)
           @element_ids = elements&.transform_values { |v| v && v.pluck(:id) }
         end
 
@@ -280,6 +289,7 @@ class CollectionAPI < Grape::API
             screen_ids: @screen_ids,
             research_plan_ids: @research_plan_ids,
             cell_line_ids: @cell_line_ids,
+            vessel_ids: @vessel_ids,
             element_ids: @element_ids,
             collection_attributes: params[:collection_attributes].merge(shared_by_id: current_user.id)
           ).execute!

app/api/chemotion/element_api.rb

@@ -38,6 +38,9 @@ class ElementAPI < Grape::API
         optional :cell_line, type: Hash do
           use :ui_state_params
         end
+        optional :vessel, type: Hash do
+          use :ui_state_params
+        end
         optional :selecteds, desc: 'Elements currently opened in detail tabs', type: Array do
           optional :type, type: String
           optional :id, type: Integer
@@ -77,7 +80,7 @@ class ElementAPI < Grape::API
       desc "delete element from ui state selection."
       delete do
         deleted = { 'sample' => [] }
-        %w[sample reaction wellplate screen research_plan cell_line].each do |element|
+        %w[sample reaction wellplate screen research_plan cell_line vessel].each do |element|
           next unless params[element]
           next unless params[element][:checkedAll] || params[element][:checkedIds].present?
 

app/api/chemotion/profile_api.rb

@@ -30,6 +30,12 @@ class ProfileAPI < Grape::API
           data[ll.to_s] = layout[ll] if layout[ll].present? && data[ll.to_s].nil?
         end
 
+        if (element_list = layout.dig(:layout))
+          element_list.each do |element, sorting|
+            data['layout'][element.to_s] = sorting if data['layout'][element.to_s].nil?
+          end
+       end
+
         if current_user.matrix_check_by_name('genericElement')
           available_elements = Labimotion::ElementKlass.where(is_active: true).pluck(:name)
           new_layout = data['layout'] || {}
@@ -134,6 +140,7 @@ class ProfileAPI < Grape::API
           'screen' => 4,
           'research_plan' => 5,
           'cell_line' => -1000,
+          'vessel' => -1100,
         } if data['layout'].nil?
 
         layout = data['layout'].select { |e| available_ements.include?(e) }

app/api/chemotion/vessel_api.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+module Chemotion
+  class VesselAPI < Grape::API
+    include Grape::Kaminari
+    helpers ParamsHelpers
+    helpers ContainerHelpers
+
+    rescue_from ActiveRecord::RecordNotFound do
+      error!('Ressource not found', 401)
+    end
+    resource :vessels do
+      desc 'return vessels of a collection'
+      params do
+        optional :collection_id, type: Integer, desc: 'Collection id'
+        optional :sync_collection_id, type: Integer, desc: 'SyncCollectionsUser id'
+        optional :filter_created_at, type: Boolean, desc: 'filter by created at or updated at'
+        optional :from_date, type: Integer, desc: 'created_date from in ms'
+        optional :to_date, type: Integer, desc: 'created_date to in ms'
+      end
+      paginate per_page: 5, offset: 0
+      before do
+        params[:per_page].to_i > 50 && (params[:per_page] = 50)
+      end
+      get do
+        scope = if params[:collection_id]
+                  begin
+                    Collection.belongs_to_or_shared_by(current_user.id, current_user.group_ids)
+                              .find(params[:collection_id]).vessels
+                  rescue ActiveRecord::RecordNotFound
+                    Vessel.none
+                  end
+                elsif params[:sync_collection_id]
+                  begin
+                    current_user.all_sync_in_collections_users
+                                .find(params[:sync_collection_id])
+                                .collection
+                                .vessels
+                  rescue ActiveRecord::RecordNotFound
+                    Vessel.none
+                  end
+                else
+                  # All collection of current_user
+                  Vessel.none.joins(:collections).where(collections: { user_id: current_user.id }).distinct
+                end.order('created_at DESC')
+
+        from = params[:from_date]
+        to = params[:to_date]
+        by_created_at = params[:filter_created_at] || false
+
+        scope = scope.created_time_from(Time.zone.at(from)) if from && by_created_at
+        scope = scope.created_time_to(Time.zone.at(to) + 1.day) if to && by_created_at
+        scope = scope.updated_time_from(Time.zone.at(from)) if from && !by_created_at
+        scope = scope.updated_time_to(Time.zone.at(to) + 1.day) if to && !by_created_at
+
+        reset_pagination_page(scope)
+
+        vessels = paginate(scope).map do |vessel|
+          Entities::VesselInstanceEntity.represent(
+            vessel,
+            displayed_in_list: true,
+            #  detail_levels: ElementDetailLevelCalculator.new(user: current_user, element: cell_line_sample).detail_levels,
+          )
+        end
+        { vessels: vessels }
+      end
+
+      desc 'Get a vessel by id'
+      params do
+        requires :id, type: String, desc: 'id of vessel instance to load'
+      end
+      get ':id' do
+        if params[:id] == 'new'
+          return present Vessel.new, with: Entities::VesselInstanceEntity
+        end
+        begin
+          vessel = Vessel.find(params[:id])
+        rescue ActiveRecord::RecordNotFound
+          error!('404 Not Found', 404)
+        rescue StandardError => e
+          error!(e, 400)
+        end
+        return present vessel, with: Entities::VesselInstanceEntity
+      end
+
+      desc 'Create a new Vessel sample'
+      params do
+        requires :template_name, type: String, desc: 'name of a vessel template'
+        optional :vessel_name, type: String, desc: 'name of a vessel sample (for single instance)'
+        optional :material_details, type: String, desc: 'details of the vessel template'
+        optional :details, type: String, desc: 'additional details'
+        optional :material_type, type: String, desc: 'vessel material type of the vessel'
+        optional :vessel_type, type: String, desc: 'type of the vessel'
+        optional :volume_amount, type: Float, desc: 'volume amount'
+        optional :volume_unit, type: String, desc: 'volume unit'
+        optional :weight_amount, type: Float, desc: 'weight of the vessel'
+        optional :weight_unit, type: String, desc: 'weight unit of the vessel'
+        optional :bar_code, type: String, desc: 'bar code of the vessel (for single instance)'
+        optional :qr_code, type: String, desc: 'qr code of the vessel (for single instance)'
+        optional :description, type: String, desc: 'description of a vessel sample (for single instance)'
+        optional :short_label, type: String, desc: 'short label of a vessel sample'
+        requires :collection_id, type: Integer, desc: 'collection of the vessel sample'
+        optional :instances, type: Array, desc: 'array of vessel instances', documentation: { is_array: true } do
+          requires :vessel_name, type: String, desc: 'name of the vessel instance'
+          optional :description, type: String, desc: 'description of the vessel instance'
+          optional :bar_code, type: String, desc: 'bar code of the vessel instance'
+          optional :qr_code, type: String, desc: 'qr code of the vessel instance'
+        end
+        requires :container, type: Hash, desc: 'root container of element'
+      end
+      post do
+        error!('401 Unauthorized', 401) unless current_user.collections.find(params[:collection_id])
+        vessel_template = VesselTemplate.find_or_create_by!(
+          name: params[:template_name],
+          details: params[:details],
+          material_details: params[:material_details],
+          material_type: params[:material_type],
+          vessel_type: params[:vessel_type],
+          volume_amount: params[:volume_amount],
+          volume_unit: params[:volume_unit],
+          weight_amount: params[:weight_amount],
+          weight_unit: params[:weight_unit]
+        )
+
+        created_vessels = []
+
+        ActiveRecord::Base.transaction do
+          (params[:instances] || []).each do |instance_params|
+            vessel = Vessel.create!(
+              vessel_template: vessel_template,
+              name: instance_params[:vessel_name],
+              user_id: current_user.id,
+              description: instance_params[:description],
+              bar_code: instance_params[:bar_code],
+              qr_code: instance_params[:qr_code],
+              short_label: params[:short_label]
+            )
+
+            if params[:collection_id]
+              collection = current_user.collections.find_by(id: params[:collection_id])
+              vessel.collections << collection if collection.present?
+            end
+
+            if params[:container]
+              begin
+                vessel.container = update_datamodel(params[:container].deep_dup)
+              rescue StandardError => e
+                Rails.logger.error "Error updating container: #{e.message}"
+                error!("Container update failed: #{e.message}", 400)
+              end
+            end
+
+            created_vessels << vessel
+          end
+        end
+
+        present created_vessels, with: Entities::VesselInstanceEntity
+      end
+
+      desc 'Update a vessel instance or associated vessel template'
+      params do
+        requires :vessel_id, type: String, desc: 'id of the vessel to update'
+        optional :vessel_template_id, type: String, desc: 'ID of the vessel template to update'
+        optional :template_name, type: String, desc: 'name of a vessel template'
+        optional :vessel_name, type: String, desc: 'name of a vessel sample'
+        optional :material_details, type: String, desc: 'details of the vessel template'
+        optional :details, type: String, desc: 'additional details'
+        optional :material_type, type: String, desc: 'vessel material type of the vessel'
+        optional :vessel_type, type: String, desc: 'type of the vessel'
+        optional :volume_amount, type: Float, desc: 'volume amount'
+        optional :volume_unit, type: String, desc: 'volume unit'
+        optional :weight_amount, type: Float, desc: 'weight of the vessel'
+        optional :weight_unit, type: String, desc: 'weight unit of the vessel'
+        optional :bar_code, type: String, desc: 'bar code of the vessel'
+        optional :qr_code, type: String, desc: 'qr code of the vessel'
+        optional :collection_id, type: Integer, desc: 'collection of the vessel sample'
+        optional :description, type: String, desc: 'description of a vessel sample'
+        optional :short_label, type: String, desc: 'short label of a vessel sample'
+        requires :container, type: Hash, desc: 'root Container of element'
+      end
+      put do
+        ActiveRecord::Base.transaction do
+          vessel = Vessel.find_by(id: params[:vessel_id])
+          error!('Vessel not found', 404) unless vessel
+
+          vessel_params = {
+            name: params[:vessel_name],
+            description: params[:description],
+            bar_code: params[:bar_code],
+            qr_code: params[:qr_code],
+            short_label: params[:short_label],
+          }.compact
+          vessel.update!(vessel_params) if vessel_params.present?
+
+          if params[:vessel_template_id]
+            vessel_template = VesselTemplate.find_by(id: params[:vessel_template_id])
+            error!('Vessel template not found', 404) unless vessel_template
+
+            unless vessel.vessel_template_id == vessel_template.id
+              error!("Vessel does not belong to the specified template", 400)
+            end
+
+            template_params = {
+              name: params[:template_name],
+              details: params[:details],
+              material_details: params[:material_details],
+              material_type: params[:material_type],
+              vessel_type: params[:vessel_type],
+              volume_amount: params[:volume_amount],
+              volume_unit: params[:volume_unit],
+              weight_amount: params[:weight_amount],
+              weight_unit: params[:weight_unit],
+            }.compact
+            vessel_template.update!(template_params) if template_params.present?
+          end
+
+          if params[:container]
+            begin
+              vessel.container = update_datamodel(params[:container])
+            rescue StandardError => e
+              Rails.logger.error "Error updating container: #{e.message}"
+              error!("Container update failed: #{e.message}", 400)
+            end
+          end
+
+          present vessel, with: Entities::VesselInstanceEntity
+        end
+      end
+
+
+
+      resource :names do
+        desc 'Returns all accessible vessel templates material names and their id'
+        get 'all' do
+          vessel_templates = VesselTemplate.select(:id, :name, :vessel_type, :material_type, :volume_amount, :volume_unit).distinct
+          present vessel_templates, with: Entities::VesselTemplateEntity
+        end
+      end
+      resource :material do
+        params do
+          requires :id, type: String, desc: 'id of vessel template to load'
+        end
+        get ':id' do
+          return VesselTemplate.find(params[:id])
+        end
+      end
+
+      desc 'Delete a Vessel'
+      params do
+        requires :id, type: String, desc: 'ID of the vessel instance to delete'
+      end
+      delete ':id' do
+        vessel = Vessel.find_by(id: params[:id])
+        if vessel.nil?
+          error!('404 Vessel Not Found', 404)
+        else
+          vessel.destroy!
+          status 200
+          { message: 'Vessel successfully deleted', vessel_id: params[:id] }
+        end
+      end
+
+      desc 'Delete a Vessel Template'
+      params do
+        requires :id, type: String, desc: 'ID of the vessel template to delete'
+      end
+      delete 'vessel_template/:id' do
+        vessel_template = VesselTemplate.find_by(id: params[:id])
+        if vessel_template.nil?
+          error!('404 VesselTemplate Not Found', 404)
+        elsif vessel_template.vessels.exists?
+          error!('400 Cannot delete VesselTemplate. It is associated with one or more vessels.', 400)
+        else
+          vessel_template.destroy!
+          status 200
+          { message: 'VesselTemplate successfully deleted', vessel_template_id: params[:id] }
+        end
+      end
+    end
+  end
+end