labimotion 2.3.0.rc5 → 2.4.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57f6db758edf09de9105830d7a9f9cfda1270ac36bb6ee4351da8ab65b2ea2dc
-  data.tar.gz: 0e220ffc2a76645f8e82536cd592d7ee9eecd28e54073b408a602da019839e9f
+  metadata.gz: 4c92bee7516a80229220d269bcc9b53d700df17b0fa78f98857476f1bdd9ab02
+  data.tar.gz: 70ebf34d13b72d35eaeb4a05e039977add30227afe2acef0c00f1d434f2ae110
 SHA512:
-  metadata.gz: f3f5ca1afdb69edbbf36f09834a04843d72d9b964db836719991a5d8b1acb10036cf4470f4ca1810bac6b629bc6908dc2ed5054127216ed9d6109b01d205ab07
-  data.tar.gz: cf72bfa7a774ef98e1474d5a4e3914304f940105137f18f05adb4b5675afdeab668e305386bda9ce1b842b2083005fc622c210d27c60b1005cfcba90c1eb2617
+  metadata.gz: 15952d33d6cceadfc8a3bb21e020e0d924b27e127e84b4fa5667e98bb34a691969d19b642d8624f233ab9c9f18adb2c36d45920594f73fc56296d2a0590c72f5
+  data.tar.gz: 2d47c8be30f7ecbbe68db65e8a6979ed7e0d8a1edff6fdaa6fe0dcf1cafbaf1e914f085fdde09385b6546f4be1ba8e0de0830a94584d9aee75d45738ba5f384a

data/CHANGELOG.md

@@ -2,13 +2,22 @@
 
 ## [Unreleased]
 * Features and enhancements:
+  * Added per-user, per-klass toolbar configuration (Overview/Arrange visibility) via `POST /user_klass_settings/save` (upsert) and `GET /user_klass_settings/fetch` ([chem-generic-ui#905](https://github.com/LabIMotion/chem-generic-ui/issues/905)). Each user stores their own `settings` (`{ toolbar: { overview, arrange } }`) per element/segment/dataset klass, keyed by the stable klass identifier so it applies to every instance of that klass across template versions. Requires host ELN twin migration `create_user_klass_settings`.
+  * Designer can enable/disable common layer functionalities (record time, add reaction, add/remove layer) per template; template-scoped and independent of template versions ([chem-generic-ui#904](https://github.com/LabIMotion/chem-generic-ui/issues/904)). Saved segments expose the effective klass `settings` so records honor the toggles after a reload. Requires host ELN twin migration `add_settings_to_klasses`.
+  * Support linking CellLine elements in the generic Link Element via the `Labimotion::CellLine` wrapper ([chem-generic-ui#906](https://github.com/LabIMotion/chem-generic-ui/issues/906)). Requires a host ELN `element_klasses` row for `cell_line` (migration) — see PR notes.
+  * `LinkedElement` resolves `cell_line` links to curated `CelllineSample` columns (previously an unknown el_klass misresolved to a generic `Labimotion::Element` sharing the same id).
+  * `LinkedElement` exposes two distinct names for `cell_line` links — the shared **Cell line name** (`material_name`, from the linked `CelllineMaterial`) and the per-sample **Name of specific sample** (`name`) — as separately selectable inline attributes.
   * Element variations can be exported to and imported from Excel (`.xlsx`). The exported workbook is itself the import template: `GET /api/v1/element_variations/:element_id/export` and `POST /api/v1/element_variations/:element_id/import`.
   * The exported sheet carries the grid's grouped header -- group, sub-group and field rows, merged as the grid draws them -- above the hidden key and unit rows. Workbooks from the earlier single-row header still import.
   * Import merges rows by uuid, so a sheet only updates the columns it carries; a row with a blank `Row ID` is added as a new variation.
   * `number`, `integer` and `system-defined` columns accept numbers only. A cell holding anything else is cleared with a warning rather than stored as text, which also cleans up text those columns already hold.
   * Import warnings name the cell they came from (`Cell I6: ...`), so the user can go straight to it in the spreadsheet.
 * Bug fixes:
-  * `fetch_for_user`: the shared-records branch joined `collection_shares` directly on the element model (an association that only exists on `Collection`), raising `ActiveRecord::ConfigurationError` — rescued into empty search results. Now joins through `collections`. Fixed for both the basic elements (`ElementFetchable`) and the generic element (`Labimotion::Element`), so `search_by_like` and `search_basic_by_like` return shared records again.
+  * `ElementFetchable#fetch_for_user`: the shared-records branch joined `collection_shares` directly on the element model (an association that only exists on `Collection`), raising `ActiveRecord::ConfigurationError` — rescued into empty search results for every element type. Now joins through `collections`.
+  * `Labimotion::Element.fetch_for_user` carried the same broken `collection_shares` join, so the generic-element `search_by_like` endpoint silently returned no shared records. Now joins through `collections` as well.
+  * `Labimotion::CellLine` delegation forwards keyword arguments on Ruby >= 3.0 (`ruby2_keywords`); without it `fetch_for_user(id, name:, short_label:, limit:)` raised `ArgumentError`.
+  * `SampleAssociation#update_sample_association` no longer creates `Labimotion::ElementsElement` join rows for drag_element values that link standard elements (e.g. `cell_line`, `reaction`), whose `el_id` is not a `Labimotion::Element` id.
+  * `Segmentable#save_segments` → `touch_analyses_properties` assumed every segmentable model defines `#analyses`; `CelllineSample` did not, so `POST /api/v1/cell_lines` raised `NameError` on create/update. Guard the analysis-vocabulary touch when `#analyses` is undefined so the save no longer fails.
 * Dependencies:
   * Added `roo` (~> 2.10) for reading the uploaded workbook.
 

data/lib/labimotion/apis/generic_element_api.rb

@@ -88,6 +88,28 @@ module Labimotion
         end
       end
 
+      namespace :linked_attributes do
+        desc 'List the selectable inline attributes of an element linked from a drag_element field'
+        params do
+          optional :el_klass, type: String, desc: 'Generic element klass name or permit-target key (reaction, sample, ...)'
+          optional :el_type, type: String, desc: 'Linked element type (element, sample, molecule, ...)'
+          requires :el_id, type: Integer, desc: 'Linked element id'
+        end
+        get do
+          linked = Labimotion::LinkedElement.new(params[:el_klass], params[:el_id], params[:el_type])
+          record = linked.record
+          error!('404 Not Found', 404) if record.nil?
+          # Reference data (molecules) is public; everything else is collection-scoped.
+          readable = record.is_a?(::Molecule) || ElementPolicy.new(current_user, record).read?
+          error!('401 Unauthorized', 401) unless readable
+
+          { attributes: linked.available }
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          { attributes: [], error: e.message }
+        end
+      end
+
       namespace :search_basic_by_like do
         desc 'Search basic elements by name and short label (case-insensitive like search)'
         params do

data/lib/labimotion/apis/generic_klass_api.rb

@@ -14,7 +14,7 @@ module Labimotion
         desc 'export klass'
         params do
           requires :id, type: Integer, desc: 'element id'
-          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+          requires :klass, type: String, desc: 'Klass', values: Labimotion::Constants::Klass::ALL
         end
         get do
           entity = "Labimotion::#{params[:klass]}".constantize.find_by(id: params[:id])
@@ -35,7 +35,7 @@ module Labimotion
       namespace :de_activate do
         desc 'activate or deactivate Generic Klass'
         params do
-          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+          requires :klass, type: String, desc: 'Klass', values: Labimotion::Constants::Klass::ALL
           requires :id, type: Integer, desc: 'Klass ID'
           requires :is_active, type: Boolean, desc: 'Active or Inactive Klass'
         end
@@ -54,11 +54,33 @@ module Labimotion
         end
       end
 
+      namespace :update_settings do
+        desc 'update Generic Klass settings'
+        params do
+          requires :klass, type: String, desc: 'Klass', values: Labimotion::Constants::Klass::ALL
+          requires :id, type: Integer, desc: 'Klass ID'
+          requires :settings, type: Hash, desc: 'Klass settings'
+        end
+        after_validation do
+          authenticate_admin!(params[:klass].gsub(/(Klass)/, 's').downcase)
+          fetch_klass(params[:klass], params[:id])
+        end
+        post do
+          updated_klass = update_klass_settings(params)
+          entity_class = "Labimotion::#{params[:klass]}Entity".constantize
+          serialized_data = entity_class.represent(updated_klass)
+          { mc: 'ss00', data: serialized_data }
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          { mc: 'se00', msg: e.message, data: {} }
+        end
+      end
+
       namespace :fetch do
         desc 'fetch Generic Klass by id'
         params do
           requires :id, type: Integer, desc: 'Klass ID'
-          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+          requires :klass, type: String, desc: 'Klass', values: Labimotion::Constants::Klass::ALL
         end
         get do
           klass_obj = fetch_klass(params[:klass], params[:id])

data/lib/labimotion/apis/labimotion_api.rb

@@ -13,6 +13,7 @@ module Labimotion
     mount Labimotion::StandardLayerAPI
     mount Labimotion::VocabularyAPI
     mount Labimotion::UserAPI
+    mount Labimotion::UserKlassSettingsAPI
     mount Labimotion::MttAPI
     mount Labimotion::ElementVariationAPI
     mount Labimotion::LabimotionDoiAPI

data/lib/labimotion/apis/user_klass_settings_api.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'labimotion/version'
+
+module Labimotion
+  # Per-user, per-klass UI settings API (toolbar Overview/Arrange visibility).
+  # Every route is scoped to the authenticated user via created_by, so a user
+  # only ever reads/writes their own setting; no klass-edit permission needed.
+  class UserKlassSettingsAPI < Grape::API
+    helpers Labimotion::ParamHelpers
+
+    helpers do
+      def settings_scope
+        Labimotion::UserKlassSetting.where(created_by: current_user.id)
+      end
+
+      def klass_toolbar(settings)
+        (settings || {})['toolbar'] || (settings || {})[:toolbar] || {}
+      end
+    end
+
+    resource :user_klass_settings do
+      desc 'Fetch the current user UI setting for a klass'
+      params do
+        requires :klass, type: String, values: %w[ElementKlass SegmentKlass DatasetKlass], desc: 'Klass type'
+        requires :identifier, type: String, desc: 'Klass identifier'
+      end
+      get 'fetch' do
+        error!('401 Unauthorized', 401) unless current_user
+
+        record = settings_scope.find_by(klass: params[:klass], klass_identifier: params[:identifier])
+        data = record ? Labimotion::UserKlassSettingEntity.represent(record) : nil
+        { mc: 'ss00', data: data }
+      rescue StandardError => e
+        Labimotion.log_exception(e, current_user)
+        { mc: 'se00', msg: e.message, data: nil }
+      end
+
+      desc 'Upsert the current user UI setting for a klass'
+      params do
+        use :user_klass_settings_save
+      end
+      post 'save' do
+        error!('401 Unauthorized', 401) unless current_user
+
+        record = settings_scope.find_or_initialize_by(
+          klass: params[:klass], klass_identifier: params[:klass_identifier]
+        )
+        record.klass_label = params[:klass_label] if params[:klass_label]
+        record.created_by ||= current_user.id
+        record.settings = (record.settings || {}).merge('toolbar' => klass_toolbar(params[:settings]))
+        record.save!
+        { mc: 'ss00', data: Labimotion::UserKlassSettingEntity.represent(record) }
+      rescue StandardError => e
+        Labimotion.log_exception(e, current_user)
+        { mc: 'se00', msg: e.message, data: {} }
+      end
+
+      desc 'List all UI settings of the current user'
+      get 'list' do
+        error!('401 Unauthorized', 401) unless current_user
+
+        { mc: 'ss00', data: Labimotion::UserKlassSettingEntity.represent(settings_scope.to_a) }
+      rescue StandardError => e
+        Labimotion.log_exception(e, current_user)
+        { mc: 'se00', msg: e.message, data: [] }
+      end
+    end
+  end
+end

data/lib/labimotion/entities/generic_klass_entity.rb

@@ -9,6 +9,7 @@ module Labimotion
     expose :properties_template, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
     expose :properties_release, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
     expose :metadata, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
+    expose :settings, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
     expose_timestamps(timestamp_fields: %i[released_at created_at updated_at sync_time])
   end
 end

data/lib/labimotion/entities/properties_entity.rb

@@ -20,6 +20,7 @@ module Labimotion
 
     def process_fields(key, layer)
       process_sample_and_molecule_fields(key, layer)
+      process_linked_attr_fields(key, layer)
       process_reaction_fields(key, layer)
       process_table_fields(key, layer)
       # process_voc_fields(key, layer)
@@ -32,6 +33,18 @@ module Labimotion
       end
     end
 
+    # Resolve the linked attributes a user chose to surface inline on a drag field
+    # (stored as value['el_attrs']). Only the selection is persisted; the current
+    # values are refreshed here from the linked element on every load. Works for
+    # drag_element (generic element or any permit-target type) as well as
+    # drag_sample / drag_molecule.
+    def process_linked_attr_fields(key, layer)
+      select_fields(layer, [Labimotion::FieldType::DRAG_ELEMENT, Labimotion::FieldType::DRAG_SAMPLE,
+                            Labimotion::FieldType::DRAG_MOLECULE]).each do |field, idx|
+        update_linked_attr_field(key, field, idx)
+      end
+    end
+
     def process_reaction_fields(key, layer)
       select_fields(layer, [Labimotion::FieldType::SYS_REACTION]).each do |field, idx|
         update_reaction_field(key, field, idx)
@@ -80,6 +93,21 @@ module Labimotion
                          })
     end
 
+    def update_linked_attr_field(key, field, idx)
+      return unless field['value'].is_a?(Hash)
+
+      attrs = field.dig('value', 'el_attrs')
+      return unless attrs.is_a?(Array) && attrs.present?
+      return unless object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx,
+                                          'value').present?
+
+      el_klass = field.dig('value', 'el_klass')
+      el_id = field.dig('value', 'el_id')
+      el_type = field.dig('value', 'el_type')
+      object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_attrs'] =
+        Labimotion::LinkedElement.new(el_klass, el_id, el_type).resolve(attrs)
+    end
+
     def update_reaction_field(key, field, idx)
       return unless field['value'].is_a?(Hash)
 

data/lib/labimotion/entities/segment_entity.rb

@@ -9,9 +9,17 @@ module Labimotion
     expose :properties, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
     expose :properties_release, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
     expose :metadata, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
+    expose :settings, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
 
     def klass_label
       object.segment_klass.label
     end
+
+    # Saved segments are serialized without their klass, so surface the
+    # template-scoped settings here; guarded for hosts not yet migrated.
+    def settings
+      klass = object.segment_klass
+      klass.respond_to?(:settings) ? klass.settings || {} : {}
+    end
   end
 end

data/lib/labimotion/entities/user_klass_setting_entity.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'labimotion/entities/application_entity'
+module Labimotion
+  # Per-user, per-klass UI setting entity
+  class UserKlassSettingEntity < Labimotion::ApplicationEntity
+    expose :id, :klass, :klass_identifier, :klass_label, :settings
+    expose_timestamps(timestamp_fields: %i[created_at])
+  end
+end

data/lib/labimotion/helpers/generic_helpers.rb

@@ -36,6 +36,15 @@ module Labimotion
       raise e
     end
 
+    def update_klass_settings(params)
+      klz = fetch_klass(params[:klass], params[:id])
+      klz&.update!(settings: (klz.settings || {}).merge(params[:settings] || {}))
+      klz
+    rescue StandardError => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
     def delete_klass(params)
       authenticate_admin!(params[:klass].gsub(/(Klass)/, 's').downcase)
       klz = fetch_klass(params[:klass], params[:id])

data/lib/labimotion/helpers/param_helpers.rb

@@ -14,6 +14,7 @@ module Labimotion
       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'
+      optional :settings, type: Hash, desc: 'Klass settings'
       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'
@@ -72,6 +73,7 @@ module Labimotion
       requires :label, type: String, desc: 'Klass label'
       optional :desc, type: String, desc: 'Klass desc'
       optional :metadata, type: Hash, desc: 'Klass metadata'
+      optional :settings, type: Hash, desc: 'Klass settings'
       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'
@@ -91,6 +93,7 @@ module Labimotion
       optional :desc, type: String, desc: 'Segment Klass Desc'
       optional :place, type: String, desc: 'Segment Klass Place', default: '100'
       optional :identifier, type: String, desc: 'Segment Identifier'
+      optional :metadata, type: Hash, desc: 'Klass metadata'
     end
 
     params :create_segment_klass_params do
@@ -152,5 +155,17 @@ module Labimotion
       requires :id, type: Integer, desc: 'Element ID'
       requires :wellplate_ids, type: Array, desc: 'Selected Wellplates'
     end
+
+    params :user_klass_settings_save do
+      requires :klass, type: String, values: %w[ElementKlass SegmentKlass DatasetKlass], desc: 'Klass type'
+      requires :klass_identifier, type: String, desc: 'Stable klass identifier'
+      optional :klass_label, type: String, desc: 'Klass label (display only)'
+      requires :settings, type: Hash do
+        optional :toolbar, type: Hash do
+          optional :overview, type: Boolean, default: true
+          optional :arrange, type: Boolean, default: true
+        end
+      end
+    end
   end
 end

data/lib/labimotion/libs/converter.rb

@@ -125,6 +125,7 @@ module Labimotion
         tmp_file.rewind
 
         filename = oat.filename
+        # name = "#{File.basename(filename, '.*')}.zip"
         name = "#{File.basename(filename, '.*')}#{File.extname(filename) == '.zip' ? '.bagit.zip' : '.zip'}"
         att = Attachment.new(
           filename: name,
@@ -246,22 +247,14 @@ module Labimotion
       dsr.each do |ds|
         layer = layers[ds[:layer]]
         next if layer.blank? || layer[Labimotion::Prop::FIELDS].blank?
-        is_unit = ds[:field].start_with?(Prop::CONVERTER_FIELD_UINT_PREFIX)
-        next if is_unit && ds[:value].nil?
 
-        field_name = ds[:field].delete_prefix(Prop::CONVERTER_FIELD_UINT_PREFIX)
-
-        fields = layer[Labimotion::Prop::FIELDS].select{ |f| f['field'] == field_name }
+        fields = layer[Labimotion::Prop::FIELDS].select{ |f| f['field'] == ds[:field] }
         fi = fields&.first
         next if fi.blank?
 
         idx = layer[Labimotion::Prop::FIELDS].find_index(fi)
-        if is_unit
-          fi['value_system'] = ds[:value]
-        else
-          fi['value'] = ds[:value]
-          fi['device'] = ds[:device] || ds[:value]
-        end
+        fi['value'] = ds[:value]
+        fi['device'] = ds[:device] || ds[:value]
         new_prop[Labimotion::Prop::LAYERS][ds[:layer]][Labimotion::Prop::FIELDS][idx] = fi
       end
       element = Container.find(dataset.element_id)&.root_element
@@ -327,37 +320,6 @@ module Labimotion
       res
     end
 
-    def self.test_conversions(tmpfile, format)
-      res = {}
-      File.open(tmpfile.path, 'r') do |file|
-        body = { file: file, format: format }
-        response = HTTParty.post(
-          uri('conversions'),
-          basic_auth: auth,
-          body: body,
-          timeout: timeout,
-        )
-        res = response.parsed_response
-      end
-      res
-    end
-
-    def self.restore(profile_id, version, hard)
-      body = { hard: hard }
-      response = HTTParty.post(
-        uri("profiles/restore/#{profile_id}/#{version}"),
-        headers: {
-          "Content-Type" => "application/json"
-        },
-        basic_auth: auth,
-        body: body.to_json,
-        timeout: timeout,
-      )
-      res = response.parsed_response
-
-      res
-    end
-
     def self.metadata(id, current_user)
       att = Attachment.find(id)
       return if att.nil? || att.attachable_id.nil? || att.attachable_type != Labimotion::Prop::CONTAINER
@@ -372,4 +334,4 @@ end
 # rubocop: enable Metrics/AbcSize
 # rubocop: enable Metrics/MethodLength
 # rubocop: enable Metrics/ClassLength
-# rubocop: enable Metrics/CyclomaticComplexity
+# rubocop: enable Metrics/CyclomaticComplexity

data/lib/labimotion/libs/linked_element.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Resolves the "inline attributes" of an element linked from a generic
+  # drag_element field.
+  #
+  # A drag_element link target is identified by the stored value's +el_klass+:
+  #   * a generic element klass name  -> the target is a Labimotion::Element and
+  #     its selectable attributes are its own property fields (layer + field);
+  #   * a permit-target key (reaction, sample, molecule, wellplate, screen,
+  #     research_plan, device_description, cell_line) -> the target is a standard
+  #     ELN model and its selectable attributes are a curated set of database columns.
+  #
+  # Used both to list the attributes a user can pick (#available) and to refresh
+  # the current values of a previously stored selection (#resolve).
+  class LinkedElement
+    SOURCE_PROPERTY = 'property'
+    SOURCE_COLUMN = 'column'
+
+    # el_klass (permit-target key) => model class name
+    MODELS = {
+      'reaction' => '::Reaction',
+      'sample' => '::Sample',
+      'molecule' => '::Molecule',
+      'wellplate' => '::Wellplate',
+      'screen' => '::Screen',
+      'research_plan' => '::ResearchPlan',
+      'device_description' => '::DeviceDescription',
+      'cell_line' => '::CelllineSample'
+    }.freeze
+
+    # Curated, scalar columns exposed per type: [column/method, label, unit_column?]
+    COLUMNS = {
+      'reaction' => [
+        %w[name Name], %w[short_label], ['status', 'Status'], ['role', 'Role'],
+        ['rxno', 'Reaction Type'], ['conditions', 'Conditions'],
+        ['duration', 'Duration'], %w[solvent Solvent]
+      ],
+      'sample' => [
+        %w[name Name], %w[short_label], ['external_label', 'External Label'],
+        ['sum_formula', 'Sum Formula'], ['molecular_mass', 'Molecular Mass'],
+        %w[purity Purity], %w[density Density],
+        ['real_amount_value', 'Real Amount', 'real_amount_unit'],
+        ['target_amount_value', 'Target Amount', 'target_amount_unit'],
+        %w[location Location]
+      ],
+      'molecule' => [
+        ['iupac_name', 'IUPAC Name'], ['sum_formular', 'Sum Formula'],
+        ['molecular_weight', 'Molecular Weight'],
+        ['exact_molecular_weight', 'Exact Molecular Weight'],
+        ['cano_smiles', 'Canonical SMILES'], ['melting_point', 'Melting Point'],
+        ['boiling_point', 'Boiling Point'], %w[density Density]
+      ],
+      'wellplate' => [
+        %w[name Name], %w[short_label], ['description', 'Description'],
+        %w[width Width], %w[height Height]
+      ],
+      'screen' => [
+        %w[name Name], ['description', 'Description'], %w[result Result],
+        %w[collaborator Collaborator], ['conditions', 'Conditions'],
+        %w[requirements Requirements]
+      ],
+      'research_plan' => [
+        %w[name Name], %w[short_label]
+      ],
+      'device_description' => [
+        %w[name Name], %w[short_label], ['serial_number', 'Serial Number'],
+        ['device_class', 'Device Class'], ['operation_mode', 'Operation Mode'],
+        ['application_name', 'Application Name'], ['vendor_url', 'Vendor URL'],
+        %w[institute Institute], %w[building Building], %w[room Room]
+      ],
+      'cell_line' => [
+        ['material_name', 'Cell line name'], ['name', 'Name of specific sample'],
+        %w[short_label], %w[description Description],
+        %w[amount Amount unit], %w[passage Passage],
+        %w[contamination Contamination]
+      ]
+    }.freeze
+
+    # Property field types whose value is a scalar worth surfacing inline.
+    PROPERTY_TYPES = %w[
+      text textarea number integer select select-multi checkbox
+      datetime system-defined formula-field text-formula ontology-select
+    ].freeze
+
+    def initialize(el_klass, el_id, el_type = nil)
+      @el_klass = el_klass.to_s
+      @el_type = el_type.to_s
+      @el_id = el_id
+    end
+
+    # drag_element keeps the linked class in +el_klass+; drag_sample / drag_molecule
+    # keep it in +el_type+ (and may omit el_klass). Resolve one effective dispatch key.
+    def target_key
+      return @target_key if defined?(@target_key)
+
+      @target_key =
+        if MODELS.key?(@el_klass) || generic_klass?(@el_klass)
+          @el_klass
+        elsif MODELS.key?(@el_type)
+          @el_type
+        else
+          ''
+        end
+    end
+
+    def column_based?
+      MODELS.key?(target_key)
+    end
+
+    def generic?
+      generic_klass?(target_key)
+    end
+
+    def record
+      return @record if defined?(@record)
+
+      @record =
+        if column_based?
+          MODELS[target_key].safe_constantize&.find_by(id: @el_id)
+        elsif generic?
+          Labimotion::Element.find_by(id: @el_id)
+        end
+    end
+
+    # All attributes the user can pick, each with its current value.
+    def available
+      return generic_attributes if generic?
+      return column_attributes if column_based?
+
+      []
+    end
+
+    # Refresh the values/labels of a previously stored selection. Selections whose
+    # source attribute no longer exists are kept but flagged as missing; for an
+    # unknown/unsupported el_klass the selection is returned untouched.
+    def resolve(selected)
+      return selected unless selected.is_a?(Array)
+      return selected unless generic? || column_based?
+
+      index = available.index_by { |a| [a['source'], a['key']] }
+      selected.map do |attr|
+        next attr unless attr.is_a?(Hash)
+
+        index[[attr['source'], attr['key']]] || attr.merge('value' => nil, 'missing' => true)
+      end
+    end
+
+    private
+
+    def generic_klass?(name)
+      name.present? && !MODELS.key?(name) && Labimotion::ElementKlass.exists?(name: name)
+    end
+
+    def generic_attributes
+      el = record
+      return [] unless el&.properties.is_a?(Hash)
+
+      attrs = []
+      layers = el.properties[Labimotion::Prop::LAYERS] || {}
+      layers.values.sort_by { |layer| layer['position'] || 0 }.each do |layer|
+        (layer[Labimotion::Prop::FIELDS] || []).each do |field|
+          next unless PROPERTY_TYPES.include?(field['type'])
+
+          attr = {
+            'source' => SOURCE_PROPERTY,
+            'key' => "#{layer['key']}::#{field['field']}",
+            'label' => field['label'].presence || field['field'],
+            'type' => field['type'],
+            'value' => field['value'],
+            'group' => layer['label'].presence || layer['key']
+          }
+          attr['value_system'] = field['value_system'] if field['value_system'].present?
+          attrs << attr
+        end
+      end
+      attrs
+    end
+
+    def column_attributes
+      rec = record
+      return [] if rec.blank?
+
+      (COLUMNS[target_key] || []).filter_map do |col, label, unit_col|
+        next unless rec.respond_to?(col)
+
+        attr = {
+          'source' => SOURCE_COLUMN,
+          'key' => col,
+          'label' => label.presence || col.to_s.humanize,
+          'type' => SOURCE_COLUMN,
+          'value' => rec.public_send(col),
+          'group' => target_key
+        }
+        attr['value_system'] = rec.public_send(unit_col) if unit_col && rec.respond_to?(unit_col) && rec.public_send(unit_col).present?
+        attr
+      end
+    end
+  end
+end

data/lib/labimotion/libs/sample_association.rb

@@ -109,6 +109,11 @@ module Labimotion
           sid = field.dig('value', 'el_id')
           next if element.nil? || sid.blank? || sid == element.id
 
+          # drag_element may link a standard element (reaction, cell_line, ...);
+          # el_id is then NOT a Labimotion::Element id, so an ElementsElement row
+          # would associate an unrelated generic element that shares the id.
+          next if Labimotion::LinkedElement::MODELS.key?(field.dig('value', 'el_klass').to_s)
+
           el = Labimotion::Element.find_by(id: sid)
           next if el.nil?
 

data/lib/labimotion/models/cellline.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# This file extends the existing CelllineSample model in the consuming app
+# and defines a Labimotion::CellLine wrapper for convenient access.
+# NB: the ELN host model is ::CelllineSample, but the wrapper is named
+# Labimotion::CellLine so that "cell_line".camelize == "CellLine" resolves
+# to it in the search_basic_by_like endpoint.
+
+# rubocop:disable Style/RedundantConstantBase
+
+ActiveSupport.on_load(:active_record) do
+  if defined?(::CelllineSample)
+    ::CelllineSample.class_eval do
+      include Labimotion::ElementFetchable
+
+      def self.element_klass_name
+        'cell_line'
+      end
+    end
+  else
+    warn '[Labimotion] CelllineSample is not defined when Labimotion extension was loaded.'
+  end
+end
+
+# Namespace wrapper to keep your preferred call style
+module Labimotion
+  module CellLine
+    class << self
+      # Delegate class methods to ::CelllineSample.
+      # ruby2_keywords is required so keyword arguments survive the *args
+      # round-trip on Ruby >= 3.0 (e.g. fetch_for_user(id, name:, limit:)).
+      ruby2_keywords def method_missing(method, *args, &block)
+        if ::CelllineSample.respond_to?(method)
+          ::CelllineSample.public_send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        ::CelllineSample.respond_to?(method, include_private) || super
+      end
+    end
+  end
+end
+
+# rubocop:enable Style/RedundantConstantBase

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

@@ -96,6 +96,8 @@ module Labimotion
     end
 
     def touch_analyses_properties(current_user)
+      return unless respond_to?(:analyses)
+
       analyses.each do |analysis|
         analysis.children.each do |child|
           dataset = child.dataset

data/lib/labimotion/models/user_klass_setting.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Per-user, per-klass UI settings (e.g. toolbar Overview/Arrange visibility).
+  # Scoped to the owning user via created_by; at most one row per
+  # (created_by, klass, klass_identifier) — see the unique index. Keyed on the
+  # stable klass identifier so it applies to every instance of that klass,
+  # across template versions.
+  class UserKlassSetting < ApplicationRecord
+    self.table_name = :user_klass_settings
+  end
+end

data/lib/labimotion/version.rb

@@ -2,5 +2,5 @@
 
 ## Labimotion Version
 module Labimotion
-  VERSION = '2.3.0.rc5'
+  VERSION = '2.4.0.rc2'
 end

data/lib/labimotion.rb

@@ -28,6 +28,7 @@ module Labimotion
   autoload :StandardLayerAPI, 'labimotion/apis/standard_layer_api'
   autoload :VocabularyAPI, 'labimotion/apis/vocabulary_api'
   autoload :UserAPI, 'labimotion/apis/user_api'
+  autoload :UserKlassSettingsAPI, 'labimotion/apis/user_klass_settings_api'
   autoload :MttAPI, 'labimotion/apis/mtt_api'
   autoload :ElementVariationAPI, 'labimotion/apis/element_variation_api'
   autoload :LabimotionDoiAPI, 'labimotion/apis/labimotion_doi_api'
@@ -56,6 +57,7 @@ module Labimotion
   ## autoload :DatasetRevisionEntity, 'labimotion/entities/dataset_revision_entity'
   autoload :VocabularyEntity, 'labimotion/entities/vocabulary_entity'
   autoload :UserEntity, 'labimotion/entities/user_entity'
+  autoload :UserKlassSettingEntity, 'labimotion/entities/user_klass_setting_entity'
   autoload :ElementVariationEntity, 'labimotion/entities/element_variation_entity'
   autoload :LabimotionTemplateDoiEntity, 'labimotion/entities/labimotion_template_doi_entity'
 
@@ -89,6 +91,7 @@ module Labimotion
   autoload :ExportDataset, 'labimotion/libs/export_dataset'
   autoload :SampleAssociation, 'labimotion/libs/sample_association'
   autoload :PropertiesHandler, 'labimotion/libs/properties_handler'
+  autoload :LinkedElement, 'labimotion/libs/linked_element'
   autoload :AttachmentHandler, 'labimotion/libs/attachment_handler'
   autoload :VocabularyHandler, 'labimotion/libs/vocabulary_handler'
   autoload :XlsxExporter, 'labimotion/libs/xlsx_exporter'
@@ -133,7 +136,9 @@ module Labimotion
 
   autoload :StdLayer, 'labimotion/models/std_layer'
   autoload :StdLayersRevision, 'labimotion/models/std_layers_revision'
+  autoload :UserKlassSetting, 'labimotion/models/user_klass_setting'
 
+  autoload :CellLine, 'labimotion/models/cellline'
   autoload :DeviceDescription, 'labimotion/models/device_description'
   autoload :DoseRespRequest, 'labimotion/models/dose_resp_request'
   autoload :DoseRespOutput, 'labimotion/models/dose_resp_output'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.3.0.rc5
+  version: 2.4.0.rc2
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -86,6 +86,7 @@ files:
 - lib/labimotion/apis/standard_api.rb
 - lib/labimotion/apis/standard_layer_api.rb
 - lib/labimotion/apis/user_api.rb
+- lib/labimotion/apis/user_klass_settings_api.rb
 - lib/labimotion/apis/vocabulary_api.rb
 - lib/labimotion/apis/wellplate_api.rb
 - lib/labimotion/collection/export.rb
@@ -110,6 +111,7 @@ files:
 - lib/labimotion/entities/segment_klass_entity.rb
 - lib/labimotion/entities/segment_revision_entity.rb
 - lib/labimotion/entities/user_entity.rb
+- lib/labimotion/entities/user_klass_setting_entity.rb
 - lib/labimotion/entities/vocabulary_entity.rb
 - lib/labimotion/helpers/converter_helpers.rb
 - lib/labimotion/helpers/dataset_helpers.rb
@@ -136,6 +138,7 @@ files:
 - lib/labimotion/libs/export_element.rb
 - lib/labimotion/libs/export_element_variations.rb
 - lib/labimotion/libs/import_element_variations.rb
+- lib/labimotion/libs/linked_element.rb
 - lib/labimotion/libs/nmr_mapper.rb
 - lib/labimotion/libs/properties_handler.rb
 - lib/labimotion/libs/sample_association.rb
@@ -143,6 +146,7 @@ files:
 - lib/labimotion/libs/template_matcher.rb
 - lib/labimotion/libs/vocabulary_handler.rb
 - lib/labimotion/libs/xlsx_exporter.rb
+- lib/labimotion/models/cellline.rb
 - lib/labimotion/models/collections_element.rb
 - lib/labimotion/models/concerns/attachment_converter.rb
 - lib/labimotion/models/concerns/datasetable.rb
@@ -182,6 +186,7 @@ files:
 - lib/labimotion/models/std_layer.rb
 - lib/labimotion/models/std_layers_revision.rb
 - lib/labimotion/models/template_submission.rb
+- lib/labimotion/models/user_klass_setting.rb
 - lib/labimotion/models/vocabulary.rb
 - lib/labimotion/models/wellplate.rb
 - lib/labimotion/usecases/build_template_doi_xml.rb