labimotion 2.3.2 → 2.4.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2682c1c72815cd6376ed94350afc4289a414a4f09c71b9788230ec4430b3f8f
-  data.tar.gz: 603d30166812d812c7c03fdc3c985cc78b2f47965ec76abbfa4481f07d41b88e
+  metadata.gz: 20affa359afd5082ac4bc5e900b3e66c2c537a4b83fc9032883e33f25dc60362
+  data.tar.gz: e8bb4ae665e5de5166790ac27ecf42a95394057a2fd93d5deebc95dc858a5189
 SHA512:
-  metadata.gz: b5dae89c2091aa2f7f4e6b59079d13f3c777c07ba0d0891ecc97daa51b8eb571e90b9517c332d035438aaa45d671184b8d0090db382d3b23fa6e96568cf0e940
-  data.tar.gz: d66337f46db2b8d49e170bd7078cfae5b45d31fcd8deb92d0c625a09037d4858f21c919339d2547500f5bef0aec67728b7221adb73652961e8ae07c81336aee2
+  metadata.gz: 7e6d407b44837ccb8758aa2a86b6c4b109350dfa50dde7ebb3affae93b070c1efba512b4db2b08f0608b165a25c1a53c4caaa3450f55c1a15e5c1401a1ca87de
+  data.tar.gz: 60c1e3df69128dda039990086d98ad816e7fcedbf74e1a90b896b9b94eb7446b3e5feb613e42770be1f8807d72e5ee3a7c07ec8eb8e158b776d5904335d07671

data/CHANGELOG.md

@@ -1,27 +1,5 @@
 # LabIMotion Changelog
 
-## [Unreleased]
-* Features and enhancements:
-  * 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:
-  * A copied element, segment or dataset keeps the template release its properties were built on (labimotion#301, labimotion#303). Saves used to stamp every new segment and every dataset save with the klass's current `uuid` and `properties_release`, and an element with whatever the client sent, so a copy of a v1.0.0 record was labelled v2.0.0 and the client never offered Reload. `Labimotion::KlassVersion` now resolves the submitted `properties['klass_uuid']` against the klass's current release and its `*_klasses_revisions`, deleted revisions included, and stores that uuid together with the matching `properties_release`. A new record whose uuid is missing or unknown follows the current release; an existing record keeps its stored uuid when none is sent, then the uuid its stored `properties_release` names, and follows the current release only when it has neither, and a uuid this instance never released (a record imported from an instance with its own release history) keeps the release stored with the record. A new element whose properties carry no uuid follows the template the client built it on; a new segment does the same, and a copied one falls back to the `klass_uuid` of the row it was copied from. The collection import stamps the release the archive names instead of the importing instance's current one: it tries the uuid inside the archived `properties_release`, then `properties['klass_uuid']`, then the `klass_uuid` column, and stores the first one this instance knows with the local release; when none resolves, the archived release keeps the uuid it names (or, naming none, the first uuid the archive carries), and the imported properties carry the same `klass_uuid` as the column. A `klass_uuid` that is not a string is ignored, and a dataset whose klass changed follows the new klass and ignores the client's release. Element create returns 404 when the template is missing or deleted, element update resolves a soft-deleted template (`with_deleted`) before writing anything, and segments and datasets of a deleted template are skipped on save. A new record whose `klass_uuid` this instance cannot resolve keeps it with the `properties_release` the client sent, only when that release names the same uuid. No migration and no client change.
-  * `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.
-* Dependencies:
-  * Added `roo` (~> 2.10) for reading the uploaded workbook.
-
-## [2.1.2]
-> Unreleased
-* Bug fixes:
-  * Stored zip attachments are opened read-only, so they are never rewritten in place. A rewrite could delete the upload on a CIFS/SMB share.
-  * A converter or NMR mapping failure no longer fails the save: the attachment ends in `ERROR` and the error is reported to Sentry. A file that is not a zip ends in `NONE`.
-  * Encrypted zips end in `ERROR` instead of being read as garbage.
-* Maintenance:
-  * `ERROR` is terminal, also for transient faults. To retry, e.g. after restoring a lost file, call `attachment.reprocess_converter!` in the Rails console.
-
 ## [2.0.0]
 > 2025-03-25
 * Features and enhancements:

data/lib/labimotion/apis/element_variation_api.rb

@@ -1,39 +1,15 @@
 # frozen_string_literal: true
 
-require 'uri'
-
 module Labimotion
   class ElementVariationAPI < Grape::API
-    XLSX_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
-
     rescue_from ActiveRecord::RecordNotFound do
       error!('404 Element not found', 404)
     end
 
-    helpers do
-      def configure_xlsx_response(filename)
-        env['api.format'] = :binary
-        content_type XLSX_CONTENT_TYPE
-        encoded = URI.encode_www_form_component(filename)
-        header('Content-Disposition', "attachment; filename=\"#{filename}\"; filename*=UTF-8''#{encoded}")
-      end
-
-      def uploaded_xlsx_path!(file)
-        filename = file[:filename].to_s
-        error!('400 Bad Request - expected an .xlsx file', 400) unless filename.downcase.end_with?('.xlsx')
-
-        tempfile = file[:tempfile]
-        error!('400 Bad Request - upload is empty', 400) if tempfile.nil?
-
-        tempfile.path
-      end
-    end
-
     resource :element_variations do
       params do
         requires :element_id, type: Integer, desc: 'Generic element id'
       end
-      # rubocop:disable Metrics/BlockLength
       route_param :element_id do
         before do
           @element = Labimotion::Element.find(params[:element_id])
@@ -56,45 +32,14 @@ module Labimotion
 
           record = Labimotion::ElementVariation.find_or_initialize_by(element_id: @element.id)
           record.variations = params[:variations] || {}
-          record.layout = params[:layout] || {} if params.key?(:layout) && record.class.column_names.include?('layout')
+          if params.key?(:layout) && record.class.column_names.include?('layout')
+            record.layout = params[:layout] || {}
+          end
           record.save!
 
           present record, with: Labimotion::ElementVariationEntity, root: 'element_variation'
         end
-
-        desc 'Export element variations as an xlsx workbook'
-        get :export do
-          exporter = Labimotion::ExportElementVariations.new(@element, user: current_user)
-          configure_xlsx_response(exporter.filename)
-          exporter.read
-        rescue StandardError => e
-          Labimotion.log_exception(e, current_user)
-          error!("500 Internal Server Error: #{e.message}", 500)
-        end
-
-        desc 'Import element variations from an xlsx workbook produced by the export'
-        params do
-          requires :file, type: File, desc: 'xlsx file'
-        end
-        post :import do
-          error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, @element).update?
-
-          path = uploaded_xlsx_path!(params[:file])
-          importer = Labimotion::ImportElementVariations.new(@element, path)
-          record = importer.execute!
-
-          {
-            element_variation: Labimotion::ElementVariationEntity.represent(record),
-            warnings: importer.warnings
-          }
-        rescue Labimotion::ImportElementVariations::InvalidWorkbook => e
-          error!(e.message, 422)
-        rescue StandardError => e
-          Labimotion.log_exception(e, current_user)
-          error!("500 Internal Server Error: #{e.message}", 500)
-        end
       end
-      # rubocop:enable Metrics/BlockLength
     end
   end
 end

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/collection/import.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'labimotion/utils/import_utils'
-require 'labimotion/libs/klass_version'
 module Labimotion
   class Import
     def self.import_repo_segment_props(instances, attachments, attachable_uuid, fields)
@@ -68,8 +67,6 @@ module Labimotion
           dataset_klass = Labimotion::DatasetKlass.find_by(ols_term_id: dk_obj['ols_term_id']) if dataset_klass.nil?
           next if dataset_klass.nil?
 
-          klass_uuid, release = archived_version(dataset_klass, dataset_klass.dataset_klasses_revisions, fields)
-          klass_uuid ||= dkr&.uuid || dataset_klass.uuid
           dataset = Labimotion::Dataset.create!(
             fields.slice(
               'properties', 'properties_release', 'metadata'
@@ -78,8 +75,7 @@ module Labimotion
               element: element,
               dataset_klass: dataset_klass,
               uuid: SecureRandom.uuid,
-              klass_uuid: klass_uuid, 'properties_release' => release,
-              'properties' => stamped_properties(fields['properties'], klass_uuid)
+              klass_uuid: dkr&.uuid || dataset_klass.uuid
             )
           )
           update_instances.call(uuid, dataset)
@@ -114,8 +110,6 @@ module Labimotion
 
         ## segment_klass = Labimotion::ImportUtils.create_segment_klass(sk_obj, segment_klass, element_klass, current_user_id)
 
-        klass_uuid, release = archived_version(segment_klass, segment_klass.segment_klasses_revisions, fields)
-        klass_uuid ||= skr&.uuid || segment_klass.uuid
         segment = Labimotion::Segment.create!(
           fields.slice(
             'properties', 'properties_release', 'metadata'
@@ -124,8 +118,7 @@ module Labimotion
             element: element,
             segment_klass: segment_klass,
             uuid: SecureRandom.uuid,
-            klass_uuid: klass_uuid, 'properties_release' => release,
-            'properties' => stamped_properties(fields['properties'], klass_uuid)
+            klass_uuid: skr&.uuid || segment_klass.uuid
           )
         )
         properties = Labimotion::ImportUtils.properties_handler(data, instances, attachments, segment, nil)
@@ -154,8 +147,6 @@ module Labimotion
         end
         next if element_klass.nil?
 
-        klass_uuid, release = archived_version(element_klass, element_klass.element_klasses_revisions, fields)
-        klass_uuid ||= ekr&.uuid || element_klass.uuid
         element = Labimotion::Element.create!(
           fields.slice(
             'name', 'properties', 'properties_release', 'metadata'
@@ -166,8 +157,7 @@ module Labimotion
               'Collection', 'Labimotion::CollectionsElement', 'element_id', 'collection_id', uuid
             ),
             uuid: SecureRandom.uuid,
-            klass_uuid: klass_uuid, 'properties_release' => release,
-            'properties' => stamped_properties(fields['properties'], klass_uuid)
+            klass_uuid: ekr&.uuid || element_klass.uuid
           )
         )
         elements[uuid] = element
@@ -184,28 +174,5 @@ module Labimotion
       Labimotion.log_exception(e)
       raise
     end
-
-    # The archive names the release a record followed in three places: the uuid inside its
-    # properties_release, properties['klass_uuid'] and the klass_uuid column. The first one this
-    # instance resolves is stored with the local release; otherwise the archive's release keeps
-    # its own uuid, so the pair stays consistent and the Reload the properties need still shows.
-    def self.archived_version(klass, revisions, fields)
-      archived_release = fields['properties_release']
-      release_uuid = Labimotion::KlassVersion.release_uuid(archived_release)
-      uuids = [release_uuid, fields.dig('properties', 'klass_uuid'), fields['klass_uuid']]
-              .filter_map { |uuid| Labimotion::KlassVersion.string_uuid(uuid).presence }.uniq
-      uuids.each do |uuid|
-        release = Labimotion::KlassVersion.release_of(klass, revisions, uuid)
-        return [uuid, release] if release
-      end
-      [release_uuid || uuids.first, archived_release]
-    end
-    private_class_method :archived_version
-
-    # The stored properties name the same release as the klass_uuid column.
-    def self.stamped_properties(properties, klass_uuid)
-      properties.is_a?(Hash) ? properties.merge('klass_uuid' => klass_uuid) : properties
-    end
-    private_class_method :stamped_properties
   end
 end

data/lib/labimotion/constants.rb

@@ -28,11 +28,5 @@ module Labimotion
       DATASET = 'DatasetKlass'
       ALL = [ELEMENT, SEGMENT, DATASET].freeze
     end
-
-    module Tpa
-      # Segments and layers sent along with reaction variations to a third-party
-      # app (see ExportTpaSegments), as segment-klass label => layer keys.
-      SEGMENT_LAYERS = { 'Mol interactions' => %w[binding_props bind_partners].freeze }.freeze
-    end
   end
 end

data/lib/labimotion/entities/application_entity.rb

@@ -8,12 +8,8 @@ module Labimotion
     # Common condition for fields that should not be displayed in list views
     DISPLAYED_IN_LIST_CONDITION = { unless: :displayed_in_list }.freeze
 
-    # ISO 8601. A zone *name* (strftime '%Z', e.g. "UTC") is not a valid ISO zone designator, so
-    # clients parsing it with moment.js fall back to `new Date()` — engine-specific behaviour.
-    ELN_TIMESTAMP_FORMAT = '%Y-%m-%dT%H:%M:%S%z'
-
     format_with(:eln_timestamp) do |datetime|
-      datetime.present? ? datetime.strftime(ELN_TIMESTAMP_FORMAT) : nil
+      datetime.present? ? datetime.strftime('%Y-%m-%d %H:%M:%S %Z') : nil
     end
   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/helpers/element_helpers.rb

@@ -3,7 +3,6 @@
 require 'grape'
 require 'labimotion/conf'
 require 'labimotion/utils/utils'
-require 'labimotion/libs/klass_version'
 # require 'labimotion/models/element_klass'
 module Labimotion
   ## ElementHelpers
@@ -66,19 +65,9 @@ module Labimotion
 
     def create_element(current_user, params)
       klass = params[:element_klass] || {}
-      element_klass = Labimotion::ElementKlass.find_by(id: klass[:id])
-      error!('Template is invalid.', 404) if element_klass.nil?
-
-      # A new element's properties carry no klass_uuid; the template the client built them on
-      # names their release, which may be older than the current one after a release mid-session.
-      klass_uuid, release = Labimotion::KlassVersion.for_create(
-        element_klass, element_klass.element_klasses_revisions,
-        Labimotion::KlassVersion.string_uuid(params[:properties]['klass_uuid']).presence || klass[:uuid],
-        client_release: params[:properties_release]
-      )
       uuid = SecureRandom.uuid
       params[:properties]['uuid'] = uuid
-      params[:properties]['klass_uuid'] = klass_uuid
+      params[:properties]['klass_uuid'] = klass[:uuid]
       params[:properties]['pkg'] = Labimotion::Utils.pkg(params[:properties]['pkg'])
       params[:properties]['klass'] = 'Element'
       params[:properties]['identifier'] = klass[:identifier]
@@ -90,9 +79,9 @@ module Labimotion
         name: params[:name],
         element_klass_id: klass[:id],
         uuid: uuid,
-        klass_uuid: klass_uuid,
+        klass_uuid: klass[:uuid],
         properties: properties,
-        properties_release: release,
+        properties_release: params[:properties_release],
         metadata: params[:metadata] || {},
         created_by: current_user.id
       }
@@ -121,12 +110,6 @@ module Labimotion
 
     def update_element_by_id(current_user, params)
       element = Labimotion::Element.find(params[:id])
-      # Resolved before the container and sample-association writes, so a missing template fails
-      # the request whole; with_deleted because a deleted template still names the release the
-      # element's properties follow. error! throws, so it escapes this method's rescue-and-log.
-      element_klass = Labimotion::ElementKlass.with_deleted.find_by(id: element.element_klass_id)
-      error!('Template is invalid.', 404) if element_klass.nil?
-
       update_datamodel(params[:container], current_user)
       properties = update_sample_association(params[:properties], current_user, element)
       params.delete(:container)
@@ -136,11 +119,7 @@ module Labimotion
       attributes = declared(params.except(:segments), include_missing: false)
       properties['pkg'] = Labimotion::Utils.pkg(properties['pkg'])
       metadata = params[:metadata] || element.metadata || {}
-      klass_uuid, release = Labimotion::KlassVersion.for_update(
-        element_klass, element_klass.element_klasses_revisions, properties['klass_uuid'], element
-      )
-      properties['klass_uuid'] = klass_uuid if klass_uuid.present?
-      if element.klass_uuid != klass_uuid || element.properties != properties || element.name != params[:name] || element.metadata != metadata
+      if element.klass_uuid != properties['klass_uuid'] || element.properties != properties || element.name != params[:name] || element.metadata != metadata
         properties['klass'] = 'Element'
         uuid = SecureRandom.uuid
         properties['uuid'] = uuid
@@ -151,8 +130,7 @@ module Labimotion
         attributes['properties'] = properties
         attributes['properties']['uuid'] = uuid
         attributes['uuid'] = uuid
-        attributes['klass_uuid'] = klass_uuid
-        attributes['properties_release'] = release
+        attributes['klass_uuid'] = properties['klass_uuid']
         attributes['metadata'] = metadata
         attributes['updated_at'] = Time.current
         element.update_columns(attributes)

data/lib/labimotion/helpers/param_helpers.rb

@@ -91,6 +91,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

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