labimotion 2.3.3 → 2.4.0.rc1

data/lib/labimotion/libs/converter.rb

@@ -6,7 +6,6 @@ require 'json'
 require 'date'
 require 'labimotion/version'
 require 'labimotion/utils/utils'
-require 'labimotion/utils/mapper_utils'
 require 'labimotion/helpers/converter_helpers'
 
 # rubocop: disable Metrics/AbcSize
@@ -21,37 +20,27 @@ module Labimotion
     end
 
     def self.process_ds(id, current_user = {})
-      ctx = { att: nil, ols: nil, dsr: [] }
-      # Savepoint: a failure leaves no half-built dataset and keeps the caller's transaction usable
-      Attachment.transaction(requires_new: true) { map_ds(id, current_user, ctx) }
-    rescue StandardError => e
-      Labimotion::Converter.logger.error ["Att ID: #{ctx[:att]&.id}, OLS: #{ctx[:ols]}", "DSR: #{ctx[:dsr]}", e.message, *e.backtrace].join($INPUT_RECORD_SEPARATOR)
-      Labimotion.report_exception(e)
-      # Terminal state: do not fail the request, and do not retry on the next save
-      ctx[:att]&.update_column(:con_state, Labimotion::ConState::ERROR)
-      Labimotion::ConState::ERROR
-    end
-
-    def self.map_ds(id, current_user, ctx)
-      att = ctx[:att] = Attachment.find_by(id: id, con_state: Labimotion::ConState::CONVERTED)
+      att = Attachment.find_by(id: id, con_state: Labimotion::ConState::CONVERTED)
       return if att.nil? || att.attachable_id.nil? || att.attachable_type != 'Container' || att.filename.split('.')&.last != 'zip'
 
       eln_ds = Container.find_by(id: att.attachable_id, container_type: 'dataset')
       return if eln_ds.nil? || eln_ds.parent.nil? || eln_ds.parent&.container_type != 'analysis'
 
-      # Never close: closing can rewrite the stored file in place
-      zip_file = Zip::File.new(att.attachment_attacher.file.url)
-      res = Labimotion::Converter.collect_metadata(zip_file, current_user)
-      Labimotion::Converter.collect_reaction_converter_metadata(att, zip_file)
-      ctx[:ols] = res[:o] unless res&.dig(:o).nil?
-      ctx[:dsr].push(res[:d]) unless res&.dig(:d).nil?
-      ctx[:dsr].flatten!
-      dataset = build_ds(att.attachable_id, ctx[:ols])
-      update_ds(dataset, ctx[:dsr], current_user) if dataset.present?
+      dsr = []
+      ols = nil
+      Zip::File.open(att.attachment_attacher.file.url) do |zip_file|
+        res = Labimotion::Converter.collect_metadata(zip_file, current_user) if att.filename.split('.')&.last == 'zip'
+        ols = res[:o] unless res&.dig(:o).nil?
+        dsr.push(res[:d]) unless res&.dig(:d).nil?
+      end
+      dsr.flatten!
+      dataset = build_ds(att.attachable_id, ols)
+      update_ds(dataset, dsr, current_user) if dataset.present?
       att.update_column(:con_state, Labimotion::ConState::COMPLETED)
-      Labimotion::ConState::COMPLETED
+    rescue StandardError => e
+      Labimotion::Converter.logger.error ["Att ID: #{att&.id}, OLS: #{ols}", "DSR: #{dsr}", e.message, *e.backtrace].join($INPUT_RECORD_SEPARATOR)
+      raise e
     end
-    private_class_method :map_ds
 
     def self.uri(api_name)
       url = Rails.configuration.converter.url
@@ -104,40 +93,13 @@ module Labimotion
       { a: oa, f: folder }
     end
 
-    def self.collect_reaction_converter_metadata(oat, zip_file)
-      zip_file.each do |entry|
-        next unless entry.name == 'metadata/reaction_variation.json'
-
-        # Create temp file
-        tmp_file = Tempfile.new(['reaction_variation', '.json'])
-        tmp_file.binmode
-
-        # Write ZIP entry content into temp file
-        entry.extract(tmp_file.path) { true }
-
-        # Create attachment
-        att = Attachment.create!(
-          filename: 'reaction_variation.json',
-          file_path: tmp_file.path,
-          content_type: 'application/json',
-          attachable_id: oat.attachable_id,
-          attachable_type: 'Container',
-          con_state: Labimotion::ConState::CONVERTED,
-          created_by: oat.created_by,
-          created_for: oat.created_for
-        )
-
-        att.save! if att.valid?
-      end
-    end
-
     def self.collect_metadata(zip_file, current_user = {}) # rubocop: disable Metrics/PerceivedComplexity
       dsr = []
       ols = nil
       zip_file.each do |entry|
         next unless entry.name == 'metadata/converter.json'
 
-        metadata = Labimotion::MapperUtils.read_entry(entry).force_encoding('UTF-8')
+        metadata = entry.get_input_stream.read.force_encoding('UTF-8')
         jdata = JSON.parse(metadata)
 
         ols = jdata['ols']
@@ -163,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,
@@ -202,9 +165,8 @@ module Labimotion
           )
         end
         if response.ok?
-          state = Labimotion::Converter.handle_response(data[:a], response, current_user)
-          # A failed dataset mapping also marks the source attachment as ERROR
-          state == Labimotion::ConState::ERROR ? state : Labimotion::ConState::PROCESSED
+          Labimotion::Converter.handle_response(data[:a], response, current_user)
+          Labimotion::ConState::PROCESSED
         else
           Labimotion::Converter.logger.error ["Converter Response Error: id: [#{data[:a]&.id}], filename: [#{data[:a]&.filename}], response: #{response}"].join($INPUT_RECORD_SEPARATOR)
           Labimotion::ConState::ERROR
@@ -285,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
@@ -366,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
@@ -411,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,193 @@
+# 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) -> 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'
+    }.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]
+      ]
+    }.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/nmr_mapper.rb

@@ -30,21 +30,7 @@ module Labimotion
 
     class << self
       def process_ds(id, current_user = {})
-        ctx = { att: nil }
-        # Savepoint: a failure leaves no half-built dataset and keeps the caller's transaction usable
-        Attachment.transaction(requires_new: true) { map_ds(id, current_user, ctx) }
-      rescue StandardError => e
-        Labimotion.log_exception(e, current_user)
-        # Not a readable zip: nothing to map, and not an error
-        return Labimotion::ConState::NONE if invalid_archive?(e, ctx[:att])
-
-        # Terminal state: do not fail the request, and do not retry on the next save
-        Labimotion.report_exception(e)
-        Labimotion::ConState::ERROR
-      end
-
-      def map_ds(id, current_user, ctx)
-        att = ctx[:att] = find_attachment(id)
+        att = find_attachment(id)
         return Labimotion::ConState::NONE if att.nil?
 
         result = process(att)
@@ -55,10 +41,9 @@ module Labimotion
 
       def process(att)
         config = Labimotion::MapperUtils.load_brucker_config
-        attacher = att&.attachment_attacher
-        return Labimotion::MapperUtils.check_if_bagit(attacher&.file&.url) if config.nil?
-
+        return if config.nil?
 
+        attacher = att&.attachment_attacher
         extracted_data = Labimotion::MapperUtils.extract_data_from_zip(attacher&.file&.url, config['sourceMap'])
         return if extracted_data.nil?
 
@@ -147,20 +132,6 @@ module Labimotion
         Attachment.find_by(id: id, con_state: Labimotion::ConState::NMR)
       end
 
-      # True when the upload itself is not a readable zip. A missing or changed file, an encrypted zip
-      # or an unsupported compression method is not covered and stays ERROR.
-      def invalid_archive?(error, att)
-        return false unless error.instance_of?(Zip::Error) || error.is_a?(Zip::DecompressionError)
-
-        file = att&.attachment_attacher&.file
-        path = file&.url
-        on_disk = path && File.size?(path)
-        return false if on_disk.nil?
-
-        recorded = file.size
-        recorded.nil? || recorded == on_disk
-      end
-
       def handle_process_result(result, att, id, current_user)
         if result[:is_bagit]
           handle_bagit_result(att, id, current_user)
@@ -174,8 +145,7 @@ module Labimotion
       def handle_bagit_result(att, id, current_user)
         att.update_column(:con_state, Labimotion::ConState::CONVERTED)
         Labimotion::Converter.metadata(id, current_user)
-        # Return the state Converter.metadata stored; CONVERTED means still waiting for an analysis dataset
-        Attachment.find_by(id: id)&.con_state || Labimotion::ConState::NONE
+        Labimotion::ConState::COMPLETED
       end
 
       def invalid_metadata?(result)

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'zip'
-
 module Labimotion
   module AttachmentConverter
     ACCEPTED_FORMATS = (Rails.configuration.try(:converter).try(:ext) || []).freeze
@@ -29,8 +27,6 @@ module Labimotion
 
         return if attachable_id.nil? && con_state != Labimotion::ConState::WAIT
 
-        # No attachable_id-changed guard: an attachment created already attached must still be processed.
-        # Each branch leaves its pending state, so the work runs once.
         current_user = User.find_by(id: created_by)
         case con_state
         when Labimotion::ConState::NMR
@@ -44,26 +40,6 @@ module Labimotion
           Labimotion::Converter.metadata(id, current_user)
         end
       end
-
-      # Run the zip mapping again for an attachment in ERROR, e.g. after its file was restored.
-      # Returns the new con_state.
-      def reprocess_converter!
-        return con_state unless has_attribute?(:con_state) && File.extname(filename.to_s.downcase) == '.zip'
-
-        path = attachment_attacher&.file&.url
-        return con_state unless path && File.size?(path)
-
-        self.con_state = converter_output?(path) ? Labimotion::ConState::CONVERTED : Labimotion::ConState::NMR
-        update_column(:con_state, con_state)
-        exec_converter
-        reload.con_state
-      end
-
-      private def converter_output?(path)
-        !Zip::File.new(path).find_entry('metadata/converter.json').nil?
-      rescue Zip::Error
-        false # not a readable zip: the NMR mapper classifies it
-      end
     end
   end
 end

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

@@ -2,7 +2,6 @@
 
 # Datasetable concern
 require 'labimotion/utils/utils'
-require 'labimotion/libs/klass_version'
 
 module Labimotion
   ## Datasetable concern
@@ -39,10 +38,7 @@ module Labimotion
 
       args = dataset_args[:dataset]
       dataset_klass_id = args[:dataset_klass_id]
-      # A deleted template has already taken its datasets with it, so there is nothing to save.
-      klass = Labimotion::DatasetKlass.with_deleted.find_by(id: dataset_klass_id)
-      return if klass.nil? || klass.deleted_at.present?
-
+      klass = Labimotion::DatasetKlass.find_by(id: dataset_klass_id)
       uuid = SecureRandom.uuid
       metadata = args[:metadata] || {}
       props = args[:properties]
@@ -50,23 +46,16 @@ module Labimotion
       props['identifier'] = klass.identifier if klass.identifier.present?
       props['uuid'] = uuid
       props['klass'] = 'Dataset'
+      props['klass_uuid'] = klass.uuid
       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)
-      # A dataset whose klass changed follows the new klass, not the release stored for the old
-      # one, so the switch resolves as a new record does. The release the client sent counts only
-      # for a new dataset; on a switch it may still describe the old klass.
-      on_same_klass = ds if ds.present? && ds.dataset_klass_id == klass.id
-      klass_uuid, release =
-        Labimotion::KlassVersion.for_record(klass, klass.dataset_klasses_revisions, props['klass_uuid'], on_same_klass,
-                                            client_release: (args[:properties_release] if ds.nil?))
-      props['klass_uuid'] = klass_uuid if klass_uuid.present?
-      if ds.present? && (ds.klass_uuid != klass_uuid || ds.properties != props || ds.metadata != metadata)
-        ds.update!(properties_release: release, uuid: uuid, dataset_klass_id: dataset_klass_id, properties: props, klass_uuid: klass_uuid, metadata: metadata)
+      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?
 
-      Labimotion::Dataset.create!(properties_release: release, uuid: uuid, dataset_klass_id: dataset_klass_id, element_type: self.class.name, element_id: id, properties: props, klass_uuid: klass_uuid, metadata: metadata)
+      Labimotion::Dataset.create!(properties_release: klass.properties_release, uuid: uuid, dataset_klass_id: dataset_klass_id, element_type: self.class.name, element_id: id, properties: props, klass_uuid: klass.uuid, metadata: metadata)
     end
 
     def destroy_datasetable

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

@@ -26,10 +26,9 @@ module Labimotion
           joins(collections: :user).where(collections: { user_id: user_id })
         )
 
-        # Shared records — collection_shares hangs off Collection, not off the
-        # element models themselves, so join through the collections association.
+        # Shared records
         shared = apply_filters.call(
-          left_joins(collections: :collection_shares).where(collection_shares: { shared_with_id: user_id })
+          left_joins(:collection_shares).where(collection_shares: { shared_with_id: user_id })
         )
 
         # Combine (remove duplicates), order, and limit

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

@@ -2,7 +2,6 @@
 
 require 'labimotion/utils/utils'
 require 'labimotion/libs/attachment_handler'
-require 'labimotion/libs/klass_version'
 
 module Labimotion
   # Segmentable concern
@@ -47,14 +46,6 @@ module Labimotion
       end
     end
 
-    # The release a new segment was built on: its properties first, then the template the client
-    # loaded, then the klass_uuid a copied row carried.
-    def submitted_segment_uuid(seg, props)
-      segment_klass = seg['segment_klass']
-      [props['klass_uuid'], (segment_klass['uuid'] if segment_klass.is_a?(Hash)), seg['klass_uuid']]
-        .map { |uuid| Labimotion::KlassVersion.string_uuid(uuid) }.find(&:present?)
-    end
-
     def touch_vocabulary(current_user)
       touch_element_properties(current_user) if instance_of?(::Labimotion::Element)
       touch_segments_properties(current_user)
@@ -66,10 +57,7 @@ module Labimotion
 
       current_user = User.find_by(id: args[:current_user_id])
       args_segments.each do |seg|
-        # A deleted template has already taken its segments with it, so there is nothing to save.
-        klass = Labimotion::SegmentKlass.with_deleted.find_by(id: seg['segment_klass_id'])
-        next if klass.nil? || klass.deleted_at.present?
-
+        klass = Labimotion::SegmentKlass.find_by(id: seg['segment_klass_id'])
         uuid = SecureRandom.uuid
         props = seg['properties']
         props['pkg'] = Labimotion::Utils.pkg(props['pkg'])
@@ -79,22 +67,15 @@ module Labimotion
         props = Labimotion::SampleAssociation.update_sample_association(props, args[:current_user_id])
         # props = Labimotion::VocabularyHandler.update_vocabularies(props, current_user, self)
         segment = Labimotion::Segment.where(element_type: self.class.name, element_id: self.id, segment_klass_id: seg['segment_klass_id']).order(id: :desc).first
-        # Like an element update, an existing segment reads the release from its properties alone.
-        submitted_uuid = segment.nil? ? submitted_segment_uuid(seg, props) : props['klass_uuid']
-        klass_uuid, release =
-          Labimotion::KlassVersion.for_record(klass, klass.segment_klasses_revisions, submitted_uuid, segment,
-                                              client_release: seg['properties_release'])
-        # props is persisted as submitted, so the resolved value goes back in: otherwise a
-        # payload without klass_uuid stores a segment whose column and properties disagree.
-        props['klass_uuid'] = klass_uuid if klass_uuid.present?
-        if segment.present? && (segment.klass_uuid != klass_uuid || segment.properties != props)
-          segment.update!(properties_release: release, properties: props, uuid: uuid, klass_uuid: klass_uuid, metadata: seg['metadata'] || {})
+        if segment.present? && (segment.klass_uuid != props['klass_uuid'] || segment.properties != props)
+          segment.update!(properties_release: klass.properties_release, properties: props, uuid: uuid, klass_uuid: props['klass_uuid'], metadata: seg['metadata'] || {})
           # segments.push(segment)
           Labimotion::Segment.where(element_type: self.class.name, element_id: self.id, segment_klass_id: seg['segment_klass_id']).where.not(id: segment.id).destroy_all
         end
         next if segment.present?
 
-        segment = Labimotion::Segment.create!(properties_release: release, segment_klass_id: seg['segment_klass_id'], element_type: self.class.name, element_id: self.id, properties: props, created_by: args[:current_user_id], uuid: uuid, klass_uuid: klass_uuid, metadata: seg['metadata'] || {})
+        props['klass_uuid'] = klass.uuid
+        segment = Labimotion::Segment.create!(properties_release: klass.properties_release, segment_klass_id: seg['segment_klass_id'], element_type: self.class.name, element_id: self.id, properties: props, created_by: args[:current_user_id], uuid: uuid, klass_uuid: klass.uuid, metadata: seg['metadata'] || {})
         # segments.push(segment)
       end
 

data/lib/labimotion/models/element.rb

@@ -141,10 +141,9 @@ module Labimotion
         joins(collections: :user).where(collections: { user_id: user_id })
       )
 
-      # Shared elements — collection_shares hangs off Collection, not off
-      # Element itself, so join through the collections association.
+      # Shared elements
       shared = apply_filters.call(
-        left_joins(collections: :collection_shares).where(collection_shares: { shared_with_id: user_id })
+        left_joins(:collection_shares).where(collection_shares: { shared_with_id: user_id })
       )
 
       # Combine (remove duplicates), order, and limit