labimotion 2.3.1 → 2.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50d1572a0d16e5ac73fdf5aa6a22e5188c9fd2f008c671fc9705a310fbd090ac
-  data.tar.gz: 85631425352102b56f1c0c9998710c0e9af6c4f416b272cee3e05cffd6c4209e
+  metadata.gz: b2682c1c72815cd6376ed94350afc4289a414a4f09c71b9788230ec4430b3f8f
+  data.tar.gz: 603d30166812d812c7c03fdc3c985cc78b2f47965ec76abbfa4481f07d41b88e
 SHA512:
-  metadata.gz: a8d4af5906da69a5ce49e100fb5ac4d63ea399bd4cc587af58dff73b2563eebe196d7658aa0257665b439be486b5f1d2bc851226bc265cd14b309e04120ae842
-  data.tar.gz: 57e90440bc487d8fc950bb408e5c8794fa0566bad76d3a731f3cc92460623234a4893fdd1f6e61ed9f2730a1ec2b045b78ff940556fa49f6e92a6bc73c7475e6
+  metadata.gz: b5dae89c2091aa2f7f4e6b59079d13f3c777c07ba0d0891ecc97daa51b8eb571e90b9517c332d035438aaa45d671184b8d0090db382d3b23fa6e96568cf0e940
+  data.tar.gz: d66337f46db2b8d49e170bd7078cfae5b45d31fcd8deb92d0c625a09037d4858f21c919339d2547500f5bef0aec67728b7221adb73652961e8ae07c81336aee2

data/CHANGELOG.md

@@ -8,10 +8,20 @@
   * `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/collection/import.rb

@@ -1,6 +1,7 @@
 # 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)
@@ -67,6 +68,8 @@ 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'
@@ -75,7 +78,8 @@ module Labimotion
               element: element,
               dataset_klass: dataset_klass,
               uuid: SecureRandom.uuid,
-              klass_uuid: dkr&.uuid || dataset_klass.uuid
+              klass_uuid: klass_uuid, 'properties_release' => release,
+              'properties' => stamped_properties(fields['properties'], klass_uuid)
             )
           )
           update_instances.call(uuid, dataset)
@@ -110,6 +114,8 @@ 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'
@@ -118,7 +124,8 @@ module Labimotion
             element: element,
             segment_klass: segment_klass,
             uuid: SecureRandom.uuid,
-            klass_uuid: skr&.uuid || segment_klass.uuid
+            klass_uuid: klass_uuid, 'properties_release' => release,
+            'properties' => stamped_properties(fields['properties'], klass_uuid)
           )
         )
         properties = Labimotion::ImportUtils.properties_handler(data, instances, attachments, segment, nil)
@@ -147,6 +154,8 @@ 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'
@@ -157,7 +166,8 @@ module Labimotion
               'Collection', 'Labimotion::CollectionsElement', 'element_id', 'collection_id', uuid
             ),
             uuid: SecureRandom.uuid,
-            klass_uuid: ekr&.uuid || element_klass.uuid
+            klass_uuid: klass_uuid, 'properties_release' => release,
+            'properties' => stamped_properties(fields['properties'], klass_uuid)
           )
         )
         elements[uuid] = element
@@ -174,5 +184,28 @@ 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/helpers/element_helpers.rb

@@ -3,6 +3,7 @@
 require 'grape'
 require 'labimotion/conf'
 require 'labimotion/utils/utils'
+require 'labimotion/libs/klass_version'
 # require 'labimotion/models/element_klass'
 module Labimotion
   ## ElementHelpers
@@ -65,9 +66,19 @@ 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]
@@ -79,9 +90,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: params[:properties_release],
+        properties_release: release,
         metadata: params[:metadata] || {},
         created_by: current_user.id
       }
@@ -110,6 +121,12 @@ 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)
@@ -119,7 +136,11 @@ module Labimotion
       attributes = declared(params.except(:segments), include_missing: false)
       properties['pkg'] = Labimotion::Utils.pkg(properties['pkg'])
       metadata = params[:metadata] || element.metadata || {}
-      if element.klass_uuid != properties['klass_uuid'] || element.properties != properties || element.name != params[:name] || element.metadata != 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
         properties['klass'] = 'Element'
         uuid = SecureRandom.uuid
         properties['uuid'] = uuid
@@ -130,7 +151,8 @@ module Labimotion
         attributes['properties'] = properties
         attributes['properties']['uuid'] = uuid
         attributes['uuid'] = uuid
-        attributes['klass_uuid'] = properties['klass_uuid']
+        attributes['klass_uuid'] = klass_uuid
+        attributes['properties_release'] = release
         attributes['metadata'] = metadata
         attributes['updated_at'] = Time.current
         element.update_columns(attributes)

data/lib/labimotion/libs/converter.rb

@@ -6,6 +6,7 @@ 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
@@ -20,30 +21,37 @@ module Labimotion
     end
 
     def self.process_ds(id, current_user = {})
-      att = Attachment.find_by(id: id, con_state: Labimotion::ConState::CONVERTED)
+      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)
       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'
 
-      dsr = []
-      ols = nil
-      Zip::File.open(att.attachment_attacher.file.url) do |zip_file|
-        if att.filename.split('.')&.last == 'zip'
-          res = Labimotion::Converter.collect_metadata(zip_file, current_user)
-          Labimotion::Converter.collect_reaction_converter_metadata(att, zip_file)
-        end
-        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?
+      # 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?
       att.update_column(:con_state, 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
+      Labimotion::ConState::COMPLETED
     end
+    private_class_method :map_ds
 
     def self.uri(api_name)
       url = Rails.configuration.converter.url
@@ -129,7 +137,7 @@ module Labimotion
       zip_file.each do |entry|
         next unless entry.name == 'metadata/converter.json'
 
-        metadata = entry.get_input_stream.read.force_encoding('UTF-8')
+        metadata = Labimotion::MapperUtils.read_entry(entry).force_encoding('UTF-8')
         jdata = JSON.parse(metadata)
 
         ols = jdata['ols']
@@ -194,8 +202,9 @@ module Labimotion
           )
         end
         if response.ok?
-          Labimotion::Converter.handle_response(data[:a], response, current_user)
-          Labimotion::ConState::PROCESSED
+          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
         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

data/lib/labimotion/libs/klass_version.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+module Labimotion
+  # Resolves which release of a template a saved element, segment or dataset follows, as
+  # the pair [klass_uuid, properties_release]. The submitted properties carry the klass_uuid
+  # they were built on; it counts when it is the klass's current release or one of its
+  # revisions, so a copy of an older record keeps that release instead of being relabelled.
+  module KlassVersion
+    # A new record without a known release, such as a new empty one, follows the current release.
+    # A copy of a record from an instance with releases of its own names a klass_uuid this one
+    # cannot resolve; it keeps the release the client sent only when that release names the same uuid.
+    def self.for_create(klass, revisions, submitted_uuid, client_release: nil)
+      uuid = string_uuid(submitted_uuid)
+      release = release_of(klass, revisions, uuid)
+      return [uuid, release] if release
+      return [uuid, client_release] if uuid.present? && release_uuid(client_release) == uuid
+
+      [klass.uuid, klass.properties_release]
+    end
+
+    # An existing record keeps its stored klass_uuid when none is submitted, then the uuid its
+    # stored release names, and follows the current release only when it has neither. A klass_uuid
+    # this instance cannot resolve (a record imported from elsewhere) keeps the release stored with it.
+    def self.for_update(klass, revisions, submitted_uuid, record)
+      uuid = string_uuid(submitted_uuid).presence || record.klass_uuid.presence
+      if uuid.nil?
+        stored_uuid = release_uuid(record.properties_release)
+        return [stored_uuid, record.properties_release] if stored_uuid
+
+        return [klass.uuid, klass.properties_release]
+      end
+
+      release = release_of(klass, revisions, uuid) || record.properties_release.presence
+      [uuid, release || klass.properties_release]
+    end
+
+    # for_update when the record exists, for_create when it is nil.
+    def self.for_record(klass, revisions, submitted_uuid, record, client_release: nil)
+      return for_create(klass, revisions, submitted_uuid, client_release: client_release) if record.nil?
+
+      for_update(klass, revisions, submitted_uuid, record)
+    end
+
+    # Revisions are soft-deleted, and deleting one does not change which release the records
+    # built on it follow, so a deleted revision still answers here.
+    def self.release_of(klass, revisions, uuid)
+      return if uuid.blank?
+      return klass.properties_release if uuid == klass.uuid
+
+      revisions.with_deleted.where(uuid: uuid).order(id: :desc).pick(:properties_release)
+    end
+
+    # Every release hash carries the uuid of the release it describes; nil when it names none.
+    def self.release_uuid(release)
+      release.is_a?(Hash) ? string_uuid(release['uuid']).presence : nil
+    end
+
+    # properties is a free-form hash, so klass_uuid can arrive as an array or a number; either
+    # would turn the revision lookup into a query matching more than the record's own release.
+    def self.string_uuid(submitted_uuid)
+      submitted_uuid.is_a?(String) ? submitted_uuid : nil
+    end
+  end
+end

data/lib/labimotion/libs/nmr_mapper.rb

@@ -30,7 +30,21 @@ module Labimotion
 
     class << self
       def process_ds(id, current_user = {})
-        att = find_attachment(id)
+        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)
         return Labimotion::ConState::NONE if att.nil?
 
         result = process(att)
@@ -133,6 +147,20 @@ 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)
@@ -146,7 +174,8 @@ module Labimotion
       def handle_bagit_result(att, id, current_user)
         att.update_column(:con_state, Labimotion::ConState::CONVERTED)
         Labimotion::Converter.metadata(id, current_user)
-        Labimotion::ConState::COMPLETED
+        # Return the state Converter.metadata stored; CONVERTED means still waiting for an analysis dataset
+        Attachment.find_by(id: id)&.con_state || Labimotion::ConState::NONE
       end
 
       def invalid_metadata?(result)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'zip'
+
 module Labimotion
   module AttachmentConverter
     ACCEPTED_FORMATS = (Rails.configuration.try(:converter).try(:ext) || []).freeze
@@ -27,6 +29,8 @@ 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
@@ -40,6 +44,26 @@ 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,6 +2,7 @@
 
 # Datasetable concern
 require 'labimotion/utils/utils'
+require 'labimotion/libs/klass_version'
 
 module Labimotion
   ## Datasetable concern
@@ -38,7 +39,10 @@ module Labimotion
 
       args = dataset_args[:dataset]
       dataset_klass_id = args[:dataset_klass_id]
-      klass = Labimotion::DatasetKlass.find_by(id: 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?
+
       uuid = SecureRandom.uuid
       metadata = args[:metadata] || {}
       props = args[:properties]
@@ -46,16 +50,23 @@ 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)
-      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)
+      # 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)
       end
       return if ds.present?
 
-      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)
+      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)
     end
 
     def destroy_datasetable

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

@@ -2,6 +2,7 @@
 
 require 'labimotion/utils/utils'
 require 'labimotion/libs/attachment_handler'
+require 'labimotion/libs/klass_version'
 
 module Labimotion
   # Segmentable concern
@@ -46,6 +47,14 @@ 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)
@@ -57,7 +66,10 @@ module Labimotion
 
       current_user = User.find_by(id: args[:current_user_id])
       args_segments.each do |seg|
-        klass = Labimotion::SegmentKlass.find_by(id: seg['segment_klass_id'])
+        # 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?
+
         uuid = SecureRandom.uuid
         props = seg['properties']
         props['pkg'] = Labimotion::Utils.pkg(props['pkg'])
@@ -67,15 +79,22 @@ 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
-        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'] || {})
+        # 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'] || {})
           # 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?
 
-        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'] || {})
+        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'] || {})
         # segments.push(segment)
       end
 

data/lib/labimotion/utils/mapper_utils.rb

@@ -6,8 +6,18 @@ 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
@@ -37,13 +47,8 @@ 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)
-      rescue Zip::Error => e
-        Rails.logger.error "Zip file error: #{e.message}"
-        nil
-      rescue StandardError => e
-        Rails.logger.error "Unexpected error extracting metadata: #{e.message}"
-        nil
       end
 
       def check_if_bagit(zip_file_url)
@@ -183,10 +188,12 @@ module Labimotion
       def process_zip_file(zip_file_url, source_map)
         final_parameters = {}
 
-        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
+        # 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)
         end
 
         return { is_bagit: false, metadata: final_parameters } if final_parameters.present?
@@ -198,6 +205,8 @@ 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)
@@ -207,7 +216,7 @@ module Labimotion
       end
 
       def process_file_entry(entry, source_config, final_parameters)
-        file_content = entry.get_input_stream.read.force_encoding(Constants::File::ENCODING)
+        file_content = read_entry(entry).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/version.rb

@@ -2,5 +2,5 @@
 
 ## Labimotion Version
 module Labimotion
-  VERSION = '2.3.1'
+  VERSION = '2.3.2'
 end

data/lib/labimotion.rb

@@ -13,6 +13,11 @@ module Labimotion
     Labimotion.logger.error(exception.backtrace.join("\n"))
   end
 
+  # Report a rescued exception to Sentry, if the host app uses it
+  def self.report_exception(exception)
+    Sentry.capture_exception(exception) if defined?(Sentry)
+  end
+
   autoload :MapperUtils, 'labimotion/utils/mapper_utils'
   autoload :Utils, 'labimotion/utils/utils'
 
@@ -89,6 +94,7 @@ module Labimotion
   autoload :ExportDataset, 'labimotion/libs/export_dataset'
   autoload :SampleAssociation, 'labimotion/libs/sample_association'
   autoload :PropertiesHandler, 'labimotion/libs/properties_handler'
+  autoload :KlassVersion, 'labimotion/libs/klass_version'
   autoload :AttachmentHandler, 'labimotion/libs/attachment_handler'
   autoload :VocabularyHandler, 'labimotion/libs/vocabulary_handler'
   autoload :XlsxExporter, 'labimotion/libs/xlsx_exporter'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.3.2
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-09-15 00:00:00.000000000 Z
+date: 2026-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: caxlsx
@@ -137,6 +137,7 @@ files:
 - lib/labimotion/libs/export_element_variations.rb
 - lib/labimotion/libs/export_tpa_segments.rb
 - lib/labimotion/libs/import_element_variations.rb
+- lib/labimotion/libs/klass_version.rb
 - lib/labimotion/libs/nmr_mapper.rb
 - lib/labimotion/libs/properties_handler.rb
 - lib/labimotion/libs/sample_association.rb