labimotion 2.3.2 → 2.4.0.rc1

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

data/lib/labimotion/utils/mapper_utils.rb

@@ -6,18 +6,8 @@ require 'zip'
 require 'labimotion/constants'
 
 module Labimotion
-  # rubyzip 2.x does not detect encrypted entries and would inflate them as garbage
-  class EncryptedZipError < Zip::Error; end
-
   class MapperUtils
     class << self
-      # Read an entry and close its stream, so no handle on the stored file stays open
-      def read_entry(entry)
-        raise EncryptedZipError, "Encrypted zip entry: #{entry.name}" if entry.encrypted?
-
-        entry.get_input_stream(&:read)
-      end
-
       def load_config(config_json)
         JSON.parse(config_json)
       rescue JSON::ParserError => e
@@ -47,18 +37,7 @@ module Labimotion
       def extract_data_from_zip(zip_file_url, source_map)
         return nil if zip_file_url.nil?
 
-        # nil means nothing to map; errors are raised so the caller can record ERROR
         process_zip_file(zip_file_url, source_map)
-      end
-
-      def check_if_bagit(zip_file_url)
-        return nil if zip_file_url.nil?
-        Zip::File.open(zip_file_url) do |zip_file|
-          zip_file.each do |entry|
-            return { is_bagit: true, metadata: nil } if bagit_metadata_file?(entry)
-          end
-        end
-
       rescue Zip::Error => e
         Rails.logger.error "Zip file error: #{e.message}"
         nil
@@ -188,12 +167,10 @@ module Labimotion
       def process_zip_file(zip_file_url, source_map)
         final_parameters = {}
 
-        # Never close: closing can rewrite the stored file in place
-        zip_file = Zip::File.new(zip_file_url)
-        source_map['sourceSelector'].each do |source_name|
-          result = process_source(zip_file, source_map[source_name], final_parameters)
-          # A BagIt zip is mapped by the converter instead
-          return result if result&.dig(:is_bagit)
+        Zip::File.open(zip_file_url) do |zip_file|
+          source_map['sourceSelector'].each do |source_name|
+            process_source(zip_file, source_map[source_name], final_parameters)
+          end
         end
 
         return { is_bagit: false, metadata: final_parameters } if final_parameters.present?
@@ -205,8 +182,6 @@ module Labimotion
         return if invalid_source_config?(source_config)
 
         zip_file.each do |entry|
-          next if entry.directory?
-
           if source_file?(entry, source_config)
             process_file_entry(entry, source_config, final_parameters)
           elsif bagit_metadata_file?(entry)
@@ -216,7 +191,7 @@ module Labimotion
       end
 
       def process_file_entry(entry, source_config, final_parameters)
-        file_content = read_entry(entry).force_encoding(Constants::File::ENCODING)
+        file_content = entry.get_input_stream.read.force_encoding(Constants::File::ENCODING)
         extracted_parameters = extract_parameters(file_content, source_config['parameters'])
         final_parameters.merge!(extracted_parameters) if extracted_parameters.present?
 

data/lib/labimotion/utils/prop.rb

@@ -1,7 +1,6 @@
 module Labimotion
   ## Converter State
   class Prop
-    CONVERTER_FIELD_UINT_PREFIX = '___unit___'.freeze
     LAYERS = 'layers'.freeze
     FIELDS = 'fields'.freeze
     SUBFIELDS = 'sub_fields'.freeze