labimotion 2.3.1 → 2.4.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50d1572a0d16e5ac73fdf5aa6a22e5188c9fd2f008c671fc9705a310fbd090ac
-  data.tar.gz: 85631425352102b56f1c0c9998710c0e9af6c4f416b272cee3e05cffd6c4209e
+  metadata.gz: 20affa359afd5082ac4bc5e900b3e66c2c537a4b83fc9032883e33f25dc60362
+  data.tar.gz: e8bb4ae665e5de5166790ac27ecf42a95394057a2fd93d5deebc95dc858a5189
 SHA512:
-  metadata.gz: a8d4af5906da69a5ce49e100fb5ac4d63ea399bd4cc587af58dff73b2563eebe196d7658aa0257665b439be486b5f1d2bc851226bc265cd14b309e04120ae842
-  data.tar.gz: 57e90440bc487d8fc950bb408e5c8794fa0566bad76d3a731f3cc92460623234a4893fdd1f6e61ed9f2730a1ec2b045b78ff940556fa49f6e92a6bc73c7475e6
+  metadata.gz: 7e6d407b44837ccb8758aa2a86b6c4b109350dfa50dde7ebb3affae93b070c1efba512b4db2b08f0608b165a25c1a53c4caaa3450f55c1a15e5c1401a1ca87de
+  data.tar.gz: 60c1e3df69128dda039990086d98ad816e7fcedbf74e1a90b896b9b94eb7446b3e5feb613e42770be1f8807d72e5ee3a7c07ec8eb8e158b776d5904335d07671

data/CHANGELOG.md

@@ -1,17 +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:
-  * `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.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/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/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

@@ -29,10 +29,7 @@ module Labimotion
       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
+        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
@@ -96,33 +93,6 @@ 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
@@ -155,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,
@@ -276,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
@@ -357,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
@@ -402,4 +334,4 @@ end
 # rubocop: enable Metrics/AbcSize
 # rubocop: enable Metrics/MethodLength
 # rubocop: enable Metrics/ClassLength
-# rubocop: enable Metrics/CyclomaticComplexity
+# rubocop: enable Metrics/CyclomaticComplexity

data/lib/labimotion/libs/linked_element.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Resolves the "inline attributes" of an element linked from a generic
+  # drag_element field.
+  #
+  # A drag_element link target is identified by the stored value's +el_klass+:
+  #   * a generic element klass name  -> the target is a Labimotion::Element and
+  #     its selectable attributes are its own property fields (layer + field);
+  #   * a permit-target key (reaction, sample, molecule, wellplate, screen,
+  #     research_plan, device_description) -> the target is a standard ELN model
+  #     and its selectable attributes are a curated set of database columns.
+  #
+  # Used both to list the attributes a user can pick (#available) and to refresh
+  # the current values of a previously stored selection (#resolve).
+  class LinkedElement
+    SOURCE_PROPERTY = 'property'
+    SOURCE_COLUMN = 'column'
+
+    # el_klass (permit-target key) => model class name
+    MODELS = {
+      'reaction' => '::Reaction',
+      'sample' => '::Sample',
+      'molecule' => '::Molecule',
+      'wellplate' => '::Wellplate',
+      'screen' => '::Screen',
+      'research_plan' => '::ResearchPlan',
+      'device_description' => '::DeviceDescription'
+    }.freeze
+
+    # Curated, scalar columns exposed per type: [column/method, label, unit_column?]
+    COLUMNS = {
+      'reaction' => [
+        %w[name Name], %w[short_label], ['status', 'Status'], ['role', 'Role'],
+        ['rxno', 'Reaction Type'], ['conditions', 'Conditions'],
+        ['duration', 'Duration'], %w[solvent Solvent]
+      ],
+      'sample' => [
+        %w[name Name], %w[short_label], ['external_label', 'External Label'],
+        ['sum_formula', 'Sum Formula'], ['molecular_mass', 'Molecular Mass'],
+        %w[purity Purity], %w[density Density],
+        ['real_amount_value', 'Real Amount', 'real_amount_unit'],
+        ['target_amount_value', 'Target Amount', 'target_amount_unit'],
+        %w[location Location]
+      ],
+      'molecule' => [
+        ['iupac_name', 'IUPAC Name'], ['sum_formular', 'Sum Formula'],
+        ['molecular_weight', 'Molecular Weight'],
+        ['exact_molecular_weight', 'Exact Molecular Weight'],
+        ['cano_smiles', 'Canonical SMILES'], ['melting_point', 'Melting Point'],
+        ['boiling_point', 'Boiling Point'], %w[density Density]
+      ],
+      'wellplate' => [
+        %w[name Name], %w[short_label], ['description', 'Description'],
+        %w[width Width], %w[height Height]
+      ],
+      'screen' => [
+        %w[name Name], ['description', 'Description'], %w[result Result],
+        %w[collaborator Collaborator], ['conditions', 'Conditions'],
+        %w[requirements Requirements]
+      ],
+      'research_plan' => [
+        %w[name Name], %w[short_label]
+      ],
+      'device_description' => [
+        %w[name Name], %w[short_label], ['serial_number', 'Serial Number'],
+        ['device_class', 'Device Class'], ['operation_mode', 'Operation Mode'],
+        ['application_name', 'Application Name'], ['vendor_url', 'Vendor URL'],
+        %w[institute Institute], %w[building Building], %w[room Room]
+      ]
+    }.freeze
+
+    # Property field types whose value is a scalar worth surfacing inline.
+    PROPERTY_TYPES = %w[
+      text textarea number integer select select-multi checkbox
+      datetime system-defined formula-field text-formula ontology-select
+    ].freeze
+
+    def initialize(el_klass, el_id, el_type = nil)
+      @el_klass = el_klass.to_s
+      @el_type = el_type.to_s
+      @el_id = el_id
+    end
+
+    # drag_element keeps the linked class in +el_klass+; drag_sample / drag_molecule
+    # keep it in +el_type+ (and may omit el_klass). Resolve one effective dispatch key.
+    def target_key
+      return @target_key if defined?(@target_key)
+
+      @target_key =
+        if MODELS.key?(@el_klass) || generic_klass?(@el_klass)
+          @el_klass
+        elsif MODELS.key?(@el_type)
+          @el_type
+        else
+          ''
+        end
+    end
+
+    def column_based?
+      MODELS.key?(target_key)
+    end
+
+    def generic?
+      generic_klass?(target_key)
+    end
+
+    def record
+      return @record if defined?(@record)
+
+      @record =
+        if column_based?
+          MODELS[target_key].safe_constantize&.find_by(id: @el_id)
+        elsif generic?
+          Labimotion::Element.find_by(id: @el_id)
+        end
+    end
+
+    # All attributes the user can pick, each with its current value.
+    def available
+      return generic_attributes if generic?
+      return column_attributes if column_based?
+
+      []
+    end
+
+    # Refresh the values/labels of a previously stored selection. Selections whose
+    # source attribute no longer exists are kept but flagged as missing; for an
+    # unknown/unsupported el_klass the selection is returned untouched.
+    def resolve(selected)
+      return selected unless selected.is_a?(Array)
+      return selected unless generic? || column_based?
+
+      index = available.index_by { |a| [a['source'], a['key']] }
+      selected.map do |attr|
+        next attr unless attr.is_a?(Hash)
+
+        index[[attr['source'], attr['key']]] || attr.merge('value' => nil, 'missing' => true)
+      end
+    end
+
+    private
+
+    def generic_klass?(name)
+      name.present? && !MODELS.key?(name) && Labimotion::ElementKlass.exists?(name: name)
+    end
+
+    def generic_attributes
+      el = record
+      return [] unless el&.properties.is_a?(Hash)
+
+      attrs = []
+      layers = el.properties[Labimotion::Prop::LAYERS] || {}
+      layers.values.sort_by { |layer| layer['position'] || 0 }.each do |layer|
+        (layer[Labimotion::Prop::FIELDS] || []).each do |field|
+          next unless PROPERTY_TYPES.include?(field['type'])
+
+          attr = {
+            'source' => SOURCE_PROPERTY,
+            'key' => "#{layer['key']}::#{field['field']}",
+            'label' => field['label'].presence || field['field'],
+            'type' => field['type'],
+            'value' => field['value'],
+            'group' => layer['label'].presence || layer['key']
+          }
+          attr['value_system'] = field['value_system'] if field['value_system'].present?
+          attrs << attr
+        end
+      end
+      attrs
+    end
+
+    def column_attributes
+      rec = record
+      return [] if rec.blank?
+
+      (COLUMNS[target_key] || []).filter_map do |col, label, unit_col|
+        next unless rec.respond_to?(col)
+
+        attr = {
+          'source' => SOURCE_COLUMN,
+          'key' => col,
+          'label' => label.presence || col.to_s.humanize,
+          'type' => SOURCE_COLUMN,
+          'value' => rec.public_send(col),
+          'group' => target_key
+        }
+        attr['value_system'] = rec.public_send(unit_col) if unit_col && rec.respond_to?(unit_col) && rec.public_send(unit_col).present?
+        attr
+      end
+    end
+  end
+end

data/lib/labimotion/libs/nmr_mapper.rb

@@ -41,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?
 

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/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

@@ -46,22 +46,6 @@ module Labimotion
         nil
       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
-      rescue StandardError => e
-        Rails.logger.error "Unexpected error extracting metadata: #{e.message}"
-        nil
-      end
-
       def extract_parameters(file_content, parameter_names)
         return nil if file_content.blank? || parameter_names.blank?
 

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