labimotion 2.4.0.rc1 → 2.4.0.rc2

data/lib/labimotion/libs/export_element_variations.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require 'labimotion/libs/xlsx_exporter'
+require 'labimotion/libs/element_variation_column_set'
+require 'labimotion/libs/element_variation_header'
+
+module Labimotion
+  ## ExportElementVariations
+  # Writes a generic element's variations to an .xlsx workbook that
+  # ImportElementVariations can read back. See ImportElementVariations for the
+  # inverse.
+  #
+  # Sheet `Variations`:
+  #   row 1  group header      (Properties / Metadata / Segments)
+  #   row 2  sub-group header  (layer or segment name)
+  #   row 3  leaf header       (field label, with its unit token)
+  #   row 4  machine column keys               (hidden)
+  #   row 5  unit token per column             (hidden)
+  #   row 6+ one row per variation
+  #
+  # Rows 1-3 mirror the banded header the React grid draws, merged the same way:
+  # a header with no level below it spans down to row 3. Rows 4 and 5 are what
+  # make the export re-importable; they are hidden so a user only ever sees the
+  # header and the data.
+  class ExportElementVariations
+    SHEET_NAME = 'Variations'
+    INFO_SHEET_NAME = 'Info'
+    SCHEMA_VERSION = 2
+    HEADER_ROWS = Labimotion::ElementVariationHeader::ROWS
+    KEY_ROW = HEADER_ROWS + 1
+    UNIT_ROW = HEADER_ROWS + 2
+    MULTI_VALUE_SEPARATOR = '; '
+    GROUP_HEADER_BG = 'C5D9F1'
+    SUB_GROUP_HEADER_BG = 'DCE6F1'
+
+    # `system-defined` is the unit-bearing numeric field type.
+    NUMERIC_FIELD_TYPES = %w[integer number system-defined].freeze
+    MULTI_VALUE_FIELD_TYPES = %w[select-multi].freeze
+
+    def initialize(element, variation: nil, user: nil, segment_klasses: nil)
+      @element = element
+      @variation = variation || element.element_variation
+      @user = user
+      @column_set = Labimotion::ElementVariationColumnSet.new(
+        element, @variation, segment_klasses: segment_klasses
+      )
+    end
+
+    attr_reader :element, :variation, :user, :column_set
+
+    def read
+      exporter.read
+    end
+
+    def to_stream
+      exporter.to_stream
+    end
+
+    def filename
+      exporter.filename
+    end
+
+    private
+
+    def exporter
+      @exporter ||= begin
+        xlsx = Labimotion::XlsxExporter.new(base_filename)
+        build_variations_sheet(xlsx)
+        build_info_sheet(xlsx)
+        xlsx
+      end
+    end
+
+    def base_filename
+      short_label = element.respond_to?(:short_label) ? element.short_label.to_s : ''
+      short_label = element.name.to_s if short_label.empty?
+      short_label = "element_#{element.id}" if short_label.empty?
+      "#{short_label}_variations_#{Time.now.strftime('%Y%m%d_%H%M%S')}".gsub(/\s+/, '_')
+    end
+
+    def columns
+      @columns ||= column_set.columns
+    end
+
+    def header
+      @header ||= Labimotion::ElementVariationHeader.new(columns)
+    end
+
+    def build_variations_sheet(xlsx)
+      # Without a block, add_worksheet just hands back the SheetBuilder; taking
+      # it that way avoids the block's instance_eval and its locals-only rule.
+      sheet = xlsx.add_worksheet(SHEET_NAME)
+      write_header(sheet)
+      write_machine_rows(sheet)
+      write_data_rows(sheet)
+      sheet.freeze_panes(UNIT_ROW, 2)
+      header.merges.each { |from, to| sheet.merge_cells(from, to) }
+      hide_machine_rows(sheet.sheet)
+    end
+
+    def write_header(sheet)
+      group_row, sub_group_row, leaf_row = header.rows
+      sheet.add_header(group_row, bg_color: GROUP_HEADER_BG, alignment: :center)
+      sheet.add_header(sub_group_row, bg_color: SUB_GROUP_HEADER_BG, alignment: :center)
+      sheet.add_header(leaf_row)
+    end
+
+    def write_machine_rows(sheet)
+      text_types = columns.map { :string }
+      sheet.add_row(columns.map(&:key), types: text_types)
+      sheet.add_row(columns.map(&:unit), types: text_types)
+    end
+
+    def write_data_rows(sheet)
+      column_set.rows.each do |row|
+        values = serialize_row(row)
+        sheet.add_row(values, types: cell_types(values))
+      end
+    end
+
+    # Axlsx infers a cell's type from its value, which would turn the group
+    # "1.10" into the number 1.1 and an analysis id list "101" into 101. Pin
+    # everything the serializer produced as a String to :string; leave the
+    # genuinely numeric cells on auto-detection.
+    def cell_types(data_row)
+      data_row.map { |value| value.is_a?(Numeric) ? nil : :string }
+    end
+
+    # SheetBuilder exposes no row-hiding helper; reach through to the Axlsx row.
+    def hide_machine_rows(worksheet)
+      [KEY_ROW - 1, UNIT_ROW - 1].each { |index| worksheet.rows[index].hidden = true }
+    end
+
+    def build_info_sheet(xlsx)
+      info = info_rows
+      analyses = analyses_rows
+
+      xlsx.add_worksheet(INFO_SHEET_NAME) do |sheet|
+        sheet.add_section('Element', info)
+        sheet.add_header(['Analysis ID', 'Name', 'Kind'])
+        analyses.each { |analysis_row| sheet.add_row(analysis_row) }
+        sheet.auto_fit_columns
+      end
+    end
+
+    def info_rows
+      rows = [
+        ['Element ID:', element.id],
+        ['Short label:', element.respond_to?(:short_label) ? element.short_label : nil],
+        ['Element class:', element_klass_label],
+        ['Exported at:', Time.now.strftime('%Y-%m-%d %H:%M:%S')]
+      ]
+      rows << ['Exported by:', user.name] if user.respond_to?(:name)
+      rows << ['Schema version:', SCHEMA_VERSION]
+      rows
+    end
+
+    def element_klass_label
+      klass = element.respond_to?(:element_klass) ? element.element_klass : nil
+      return nil if klass.nil?
+
+      klass.respond_to?(:label) && !klass.label.to_s.empty? ? klass.label : klass.name
+    end
+
+    def analyses_rows
+      element_analyses.map do |analysis|
+        kind = analysis.respond_to?(:extended_metadata) ? (analysis.extended_metadata || {})['kind'] : nil
+        [analysis.id, analysis.name, kind]
+      end
+    end
+
+    def element_analyses
+      return [] unless element.respond_to?(:analyses)
+
+      Array(element.analyses)
+    rescue StandardError
+      []
+    end
+
+    # ---- cell serialization ----------------------------------------------
+
+    def serialize_row(row)
+      columns.map { |column| serialize_cell(column, row) }
+    end
+
+    def serialize_cell(column, row)
+      case column.kind
+      when :uuid then row['uuid'].to_s
+      when :name then row['name'].to_s
+      when :property then serialize_property(column, row)
+      when :metadata then serialize_metadata(column, row)
+      when :segment then serialize_segment(column, row)
+      end
+    end
+
+    def serialize_property(column, row)
+      key = column.key.sub(/\Aprop:/, '')
+      cell = (row['properties'] || {})[key]
+      return nil unless cell.is_a?(Hash)
+
+      coerce_out(cell['value'], column.field_type)
+    end
+
+    def serialize_metadata(column, row)
+      field = column.key.sub(/\Ameta:/, '')
+      value = (row['metadata'] || {})[field]
+      field == 'analyses' ? join_multi(value) : coerce_out(value, field)
+    end
+
+    def serialize_segment(column, row)
+      _, klass_id, field_key = column.key.split(':', 3)
+      value = row.dig('segments', klass_id.to_s, field_key)
+      coerce_out(value, column.field_type)
+    end
+
+    def coerce_out(value, field_type)
+      return nil if value.nil? || value == ''
+      return join_multi(value) if value.is_a?(Array)
+      return numeric_or_raw(value) if NUMERIC_FIELD_TYPES.include?(field_type.to_s)
+      return join_multi(value) if MULTI_VALUE_FIELD_TYPES.include?(field_type.to_s)
+
+      value.is_a?(String) ? value : value.to_s
+    end
+
+    def join_multi(value)
+      return nil if value.nil?
+      return nil if value.is_a?(Array) && value.empty?
+      return value.join(MULTI_VALUE_SEPARATOR) if value.is_a?(Array)
+
+      value.to_s
+    end
+
+    # Write numbers as numbers so a spreadsheet app treats them as such; fall
+    # back to the raw string when the stored value is not actually numeric.
+    def numeric_or_raw(value)
+      return value if value.is_a?(Numeric)
+
+      text = value.to_s.strip
+      float = Float(text)
+      (float % 1).zero? && !text.include?('.') ? float.to_i : float
+    rescue ArgumentError, TypeError
+      value.to_s
+    end
+  end
+end

data/lib/labimotion/libs/import_element_variations.rb

@@ -0,0 +1,411 @@
+# frozen_string_literal: true
+
+require 'caxlsx'
+require 'roo'
+require 'securerandom'
+require 'labimotion/libs/element_variation_column_set'
+
+module Labimotion
+  ## ImportElementVariations
+  # Reads an .xlsx workbook produced by ExportElementVariations back into an
+  # element's variations.
+  #
+  # Rows are merged by uuid: a sheet row updates only the columns the sheet
+  # actually carries, variations absent from the sheet are left untouched, and a
+  # row with a blank `__uuid` becomes a new variation. A wholesale replace would
+  # silently drop data held in columns the user had not selected when exporting.
+  class ImportElementVariations
+    SHEET_NAME = 'Variations'
+    # The machine key row is found by its `__uuid` cell rather than fixed at a
+    # row number, so a workbook from an older export -- whose header was one row
+    # instead of three -- still imports.
+    KEY_ROW_SEARCH_LIMIT = 8
+    MULTI_VALUE_SEPARATOR = ';'
+    GROUP_DISALLOWED = /[^a-zA-Z0-9_\-.,\s]/
+    GROUP_MAX_LENGTH = 64
+    # A cell whose value a column cannot hold. Treated like a blank cell: it
+    # clears what the column held, but never adds a value that was not there.
+    REJECTED = Object.new.freeze
+
+    class InvalidWorkbook < StandardError; end
+
+    def initialize(element, file_path, segment_klasses: nil, record: nil)
+      @element = element
+      @file_path = file_path
+      @segment_klasses = segment_klasses
+      @record = record
+      @warnings = []
+    end
+
+    attr_reader :element, :file_path, :warnings
+
+    def execute!
+      sheet = open_sheet
+      mapping = build_column_mapping(sheet)
+      parsed_rows = parse_rows(sheet, mapping)
+      persist(parsed_rows)
+    end
+
+    private
+
+    def record
+      @record ||= Labimotion::ElementVariation.find_or_initialize_by(element_id: element.id)
+    end
+
+    def column_set
+      @column_set ||= Labimotion::ElementVariationColumnSet.new(
+        element, record, segment_klasses: @segment_klasses
+      )
+    end
+
+    # ---- workbook reading -------------------------------------------------
+
+    def open_sheet
+      workbook = Roo::Spreadsheet.open(file_path, extension: :xlsx)
+      unless workbook.sheets.include?(SHEET_NAME)
+        raise InvalidWorkbook, "Sheet '#{SHEET_NAME}' not found. Use a file produced by the variations export."
+      end
+
+      workbook.sheet(SHEET_NAME)
+    rescue Roo::Error, Zip::Error, IOError => e
+      raise InvalidWorkbook, "Cannot read the file as .xlsx: #{e.message}"
+    end
+
+    # The machine key row is immediately followed by the unit row, and the data
+    # starts after it. Both are hidden in the exported workbook.
+    def key_row(sheet)
+      @key_row ||= begin
+        limit = [sheet.last_row.to_i, KEY_ROW_SEARCH_LIMIT].min
+        found = (1..limit).find do |number|
+          Array(sheet.row(number)).any? do |cell|
+            cell.to_s.strip == Labimotion::ElementVariationColumnSet::UUID_KEY
+          end
+        end
+        found || raise(
+          InvalidWorkbook,
+          "No column key row found: none of the first #{KEY_ROW_SEARCH_LIMIT} rows carries a " \
+          "'#{Labimotion::ElementVariationColumnSet::UUID_KEY}' cell. " \
+          'Use a file produced by the variations export.'
+        )
+      end
+    end
+
+    # Column index -> { key:, unit: }.
+    def build_column_mapping(sheet)
+      keys = safe_row(sheet, key_row(sheet))
+      units = safe_row(sheet, key_row(sheet) + 1)
+
+      mapping = {}
+      keys.each_with_index do |key, index|
+        key = key.to_s.strip
+        next if key.empty?
+
+        mapping[index] = { key: key, unit: units[index].to_s.strip }
+      end
+
+      validate_mapping!(mapping, key_row(sheet))
+      warn_unknown_keys(mapping)
+      mapping
+    end
+
+    def warn_unknown_keys(mapping)
+      unknown = mapping.reject { |_index, column| known_key?(column[:key]) }
+      return if unknown.empty?
+
+      named = unknown.map { |index, column| "#{column_ref(index)} (#{column[:key]})" }
+      @warnings << "Ignored unknown column(s) #{named.join(', ')} - the element schema may have " \
+                   'changed since this file was exported.'
+    end
+
+    def known_key?(key)
+      key == Labimotion::ElementVariationColumnSet::UUID_KEY || !column_set.lookup(key).nil?
+    end
+
+    def validate_mapping!(mapping, key_row_number)
+      keys = mapping.values.map { |column| column[:key] }
+      missing = [
+        Labimotion::ElementVariationColumnSet::UUID_KEY,
+        Labimotion::ElementVariationColumnSet::NAME_KEY
+      ] - keys
+      return if missing.empty?
+
+      raise InvalidWorkbook,
+            "Row #{key_row_number} is missing the column keys #{missing.join(', ')}. " \
+            'Use a file produced by the variations export.'
+    end
+
+    def safe_row(sheet, number)
+      return [] if sheet.last_row.nil? || sheet.last_row < number
+
+      Array(sheet.row(number))
+    end
+
+    def parse_rows(sheet, mapping)
+      last_row = sheet.last_row.to_i
+      first_data_row = key_row(sheet) + 2
+      return [] if last_row < first_data_row
+
+      (first_data_row..last_row).filter_map do |number|
+        cells = Array(sheet.row(number))
+        next if cells.all? { |cell| blank_cell?(cell) }
+
+        parse_row(cells, mapping, number)
+      end
+    end
+
+    # Each cell carries the spreadsheet reference it came from, so a warning can
+    # point the user at the cell to fix rather than just naming the bad value.
+    def parse_row(cells, mapping, row_number)
+      parsed = { uuid: nil, cells: {} }
+      mapping.each do |index, column|
+        value = cells[index]
+        if column[:key] == Labimotion::ElementVariationColumnSet::UUID_KEY
+          parsed[:uuid] = blank_cell?(value) ? nil : cell_to_s(value)
+        else
+          parsed[:cells][column[:key]] =
+            { value: value, unit: column[:unit], ref: cell_ref(index, row_number) }
+        end
+      end
+      parsed
+    end
+
+    # 0-based column index to the A1 notation a spreadsheet app shows.
+    def column_ref(column_index)
+      Axlsx.col_ref(column_index)
+    end
+
+    def cell_ref(column_index, row_number)
+      "#{column_ref(column_index)}#{row_number}"
+    end
+
+    # ---- merging ----------------------------------------------------------
+
+    def persist(parsed_rows)
+      variations = deep_dup(record.variations_hash)
+      row_order = []
+
+      parsed_rows.each do |parsed|
+        uuid = parsed[:uuid] || SecureRandom.uuid
+        base = variations[uuid] || empty_row(uuid)
+        variations[uuid] = merge_row(base, parsed[:cells], uuid)
+        row_order << uuid
+      end
+
+      record.variations = variations
+      apply_row_order(row_order, variations.keys)
+      record.save!
+      record
+    end
+
+    def apply_row_order(row_order, all_uuids)
+      return unless record.respond_to?(:layout=)
+      return unless record.class.respond_to?(:column_names) && record.class.column_names.include?('layout')
+
+      layout = deep_dup(record.layout_hash)
+      layout['rowOrder'] = row_order + (all_uuids - row_order)
+      record.layout = layout
+    end
+
+    def empty_row(uuid)
+      {
+        'uuid' => uuid,
+        'name' => 'Variation',
+        'properties' => {},
+        'metadata' => { 'notes' => '', 'analyses' => [], 'group' => '' },
+        'segments' => {}
+      }
+    end
+
+    def merge_row(base, cells, uuid)
+      row = deep_dup(base)
+      row['uuid'] = uuid
+      row['properties'] ||= {}
+      row['metadata'] ||= {}
+      row['segments'] ||= {}
+
+      cells.each do |key, cell|
+        column = column_set.lookup(key)
+        next if column.nil?
+
+        apply_cell(row, column, cell)
+      end
+      row
+    end
+
+    def apply_cell(row, column, cell)
+      case column.kind
+      when :name then row['name'] = blank_cell?(cell[:value]) ? row['name'] : cell_to_s(cell[:value])
+      when :property then apply_property(row, column, cell)
+      when :metadata then apply_metadata(row, column, cell)
+      when :segment then apply_segment(row, column, cell)
+      end
+    end
+
+    def apply_property(row, column, cell)
+      key = column.key.sub(/\Aprop:/, '')
+      existing = row['properties'][key]
+
+      # A blank cell for a property the row never had is not a deletion.
+      return if existing.nil? && blank_cell?(cell[:value])
+
+      value = if analyses_field?(column.field_type)
+                analysis_ids(cell[:value], cell[:ref])
+              else
+                coerce_in(cell, column)
+              end
+      if value.equal?(REJECTED)
+        return if existing.nil? # never stored, so there is nothing to clear
+
+        value = nil
+      end
+
+      base_cell = existing.is_a?(Hash) ? existing : {}
+      row['properties'][key] = base_cell.merge('value' => value, 'unit' => cell[:unit])
+    end
+
+    def apply_metadata(row, column, cell)
+      field = column.key.sub(/\Ameta:/, '')
+      row['metadata'][field] =
+        case field
+        when 'analyses' then analysis_ids(cell[:value], cell[:ref])
+        when 'group' then sanitize_group(cell[:value])
+        else blank_cell?(cell[:value]) ? '' : cell_to_s(cell[:value])
+        end
+    end
+
+    def apply_segment(row, column, cell)
+      _, klass_id, field_key = column.key.split(':', 3)
+      snapshot = row['segments'][klass_id.to_s]
+      return if snapshot.nil? && blank_cell?(cell[:value])
+
+      value = coerce_in(cell, column)
+      if value.equal?(REJECTED)
+        return if snapshot.nil? # never stored, so there is nothing to clear
+
+        value = nil
+      end
+
+      snapshot ||= {}
+      snapshot[field_key] = value
+      row['segments'][klass_id.to_s] = snapshot
+    end
+
+    # ---- value coercion ---------------------------------------------------
+
+    def coerce_in(cell, column)
+      value = cell[:value]
+      return nil if blank_cell?(value)
+
+      case column.field_type.to_s
+      when 'integer' then to_integer(cell, column)
+      when 'number', 'system-defined' then to_number(cell, column)
+      when 'select-multi' then split_multi(value)
+      else cell_to_s(value)
+      end
+    end
+
+    def to_integer(cell, column)
+      float = numeric(cell[:value])
+      return reject(cell, column, 'takes numbers only') if float.nil?
+      return reject(cell, column, 'takes whole numbers only') unless (float % 1).zero?
+
+      float.to_i
+    end
+
+    # xlsx has a single numeric type, so a stored 1.0 comes back as 1. Normalise
+    # integral values to Integer rather than leave the result depending on how
+    # the spreadsheet happened to round-trip the cell.
+    def to_number(cell, column)
+      float = numeric(cell[:value])
+      return reject(cell, column, 'takes numbers only') if float.nil?
+
+      (float % 1).zero? ? float.to_i : float
+    end
+
+    # Strict: "12abc" is not a number. A single comma reads as the decimal
+    # separator. Kept in step with coerceFieldValue in the React grid, so a cell
+    # cannot mean one thing there and another here.
+    def numeric(value)
+      return value.to_f if value.is_a?(Numeric)
+
+      Float(value.to_s.strip.sub(',', '.'))
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    # A numeric column holds a number or nothing at all. The text is not stored,
+    # and whatever the column held before is cleared: keeping it would leave the
+    # grid showing the very value the warning says was not accepted -- and that
+    # value may itself be text, from before these columns were checked.
+    def reject(cell, column, reason)
+      @warnings << "Cell #{cell[:ref]}: cleared '#{cell_to_s(cell[:value])}' - " \
+                   "#{column.label} #{reason}."
+      REJECTED
+    end
+
+    def split_multi(value)
+      return value if value.is_a?(Array)
+
+      cell_to_s(value).split(MULTI_VALUE_SEPARATOR).map(&:strip).reject(&:empty?)
+    end
+
+    def analyses_field?(field_type)
+      field_type.to_s == Labimotion::ElementVariationColumnSet::ANALYSES_FIELD
+    end
+
+    def analysis_ids(value, ref)
+      return [] if blank_cell?(value)
+
+      ids = split_multi(value).filter_map do |token|
+        Integer(token)
+      rescue ArgumentError, TypeError
+        @warnings << "Cell #{ref}: ignored non-numeric analysis reference '#{token}'."
+        nil
+      end
+
+      known, unknown = ids.partition { |id| element_analysis_ids.include?(id) }
+      unless unknown.empty?
+        @warnings << "Cell #{ref}: ignored analysis id(s) #{unknown.join(', ')} - " \
+                     'they do not belong to this element.'
+      end
+      known
+    end
+
+    def element_analysis_ids
+      @element_analysis_ids ||= begin
+        element.respond_to?(:analyses) ? Array(element.analyses).map(&:id) : []
+      rescue StandardError
+        []
+      end
+    end
+
+    def sanitize_group(value)
+      return '' if blank_cell?(value)
+
+      cell_to_s(value).gsub(GROUP_DISALLOWED, '')[0, GROUP_MAX_LENGTH].to_s
+    end
+
+    # ---- cell helpers -----------------------------------------------------
+
+    def blank_cell?(value)
+      value.nil? || (value.is_a?(String) && value.strip.empty?)
+    end
+
+    # Roo hands back Floats for anything numeric-looking, so an integral value
+    # from a text column would otherwise stringify as "12.0".
+    def cell_to_s(value)
+      return value if value.is_a?(String)
+      return format('%d', value) if value.is_a?(Float) && (value % 1).zero?
+
+      value.to_s
+    end
+
+    def deep_dup(value)
+      case value
+      when Hash then value.each_with_object({}) { |(key, val), acc| acc[key] = deep_dup(val) }
+      when Array then value.map { |item| deep_dup(item) }
+      else value
+      end
+    end
+  end
+end

data/lib/labimotion/libs/linked_element.rb

@@ -8,8 +8,8 @@ module Labimotion
   #   * 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.
+  #     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).
@@ -25,7 +25,8 @@ module Labimotion
       'wellplate' => '::Wellplate',
       'screen' => '::Screen',
       'research_plan' => '::ResearchPlan',
-      'device_description' => '::DeviceDescription'
+      'device_description' => '::DeviceDescription',
+      'cell_line' => '::CelllineSample'
     }.freeze
 
     # Curated, scalar columns exposed per type: [column/method, label, unit_column?]
@@ -67,6 +68,12 @@ module Labimotion
         ['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
 

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?