labimotion 2.0.0.rc1 → 2.0.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ba4a246b95d088b7928826074a223b671bd3ff8ac7c4bce5904ff983aec1534
-  data.tar.gz: c1393205315928947b688566db60ac311eef1fcfccedbb395e521a2dbdfdfbdd
+  metadata.gz: 9d75eb36d68f9212354fef2d83838274d4a4b59a59852c80ce2f0c26f2852c95
+  data.tar.gz: 1cc4625e88286bcd2febeb0b2ded75c3091f416c93db7d505e703ed04e8ce849
 SHA512:
-  metadata.gz: fbf716f60ca698f40f332b318d55747266d23ffa0c066f2afb5eff44f90c54db1402d8b42e251641fa1564aff167c79abe86411c519653c59ffbca36991a85fd
-  data.tar.gz: 4dbeae09a3740df12533e217e11d4fbc003894280ccc9d6f46e2042cf4b0ff4b2ce448215a9d918e38b077458caba39e26c55a31870b9e9e7f753f8d25bfc41b
+  metadata.gz: c630024f9111ad2c991cf8a442d8958fa4641f1b050a1c9894fab37ad1208537a650065139a13243ba560ad1c77cf77a633a3c74853a7c2857833331b3f03123
+  data.tar.gz: 4cee0102f4d4e88ba2e840eccada4294751de262c4b7a232cda167cca23970550df901343a7b1e6a0f1e5c66b4c803bd4e6b0e126ea708ca94a24579e7285b50

data/lib/labimotion/apis/standard_api.rb

@@ -13,8 +13,7 @@ module Labimotion
           use :create_std_layer_params
         end
         post do
-          # authenticate_admin!('elements')
-          # create_element_klass(current_user, params)
+          authenticate_admin!('standard_layers')
           create_std_layer(current_user, params)
           status 201
         rescue ActiveRecord::RecordInvalid => e

data/lib/labimotion/apis/standard_layer_api.rb

@@ -7,14 +7,13 @@ module Labimotion
   class StandardLayerAPI < Grape::API
     include Grape::Kaminari
     helpers Labimotion::ParamHelpers
+    helpers Labimotion::GenericHelpers
 
     resource :layers do
       namespace :get_all_layers do
         desc 'get all standard layers for designer'
         get do
           list = Labimotion::StdLayer.all.sort_by { |e| e.name }
-          # present list, with: Labimotion::StdLayer, root: 'klass'
-          # data = Labimotion::StdLayer.represent(col_tree, serializable: true)
           return { mc: 'ss00', data: list }
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)
@@ -24,17 +23,9 @@ module Labimotion
 
       namespace :get_standard_layer do
         desc 'get standard layer by id'
-        # params do
-        #   requires :id, type: Integer, desc: 'Layer id'
-        # end
         route_param :id do
-          before do
-          #   @element_policy = ElementPolicy.new(current_user, Labimotion::Element.find(params[:id]))
-          #   error!('401 Unauthorized', 401) unless current_user.matrix_check_by_name('genericElement') && @element_policy.read?
-          # rescue ActiveRecord::RecordNotFound
-          #   error!('404 Not Found', 404)
-          end
           get do
+            authenticate_admin!('standard_layers')
             entity = Labimotion::StdLayer.find(params[:id])
             return { mc: 'ss00', data: entity }
           rescue StandardError => e
@@ -50,13 +41,9 @@ module Labimotion
           use :std_layer_save
         end
         before do
+          authenticate_admin!('standard_layers')
           cur_layer = Labimotion::StdLayer.find_by(name: params[:key])
           error!('Error! duplicate name', 409) if cur_layer.present?
-          # @element_policy = ElementPolicy.new(current_user, Labimotion::Element.find(params[:id]))
-          # error!('401 Unauthorized', 401) unless current_user.matrix_check_by_name('genericElement') && @element_policy.read?
-        # rescue ActiveRecord::RecordNotFound
-        #   Labimotion.log_exception(e, current_user)
-        #   error!('404 Not Found', 404)
         end
         post do
           attributes = {
@@ -83,7 +70,7 @@ module Labimotion
         end
         route_param :id do
           before do
-            # error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, StdLayer.find(params[:id])).destroy?
+            authenticate_admin!('standard_layers')
           end
           delete do
             entity = Labimotion::StdLayer.find(params[:id])

data/lib/labimotion/apis/vocabulary_api.rb

@@ -7,6 +7,7 @@ module Labimotion
   class VocabularyAPI < Grape::API
     include Grape::Kaminari
     helpers Labimotion::ParamHelpers
+    helpers Labimotion::GenericHelpers
 
     resource :vocab do
       namespace :save_vocabulary do
@@ -15,7 +16,7 @@ module Labimotion
           use :vocab_save
         end
         before do
-          # error!('Error! duplicate record', 409) if ???.present?
+          authenticate_admin!('vocabularies')
         rescue ActiveRecord::RecordNotFound
           error!('404 Not Found', 404)
         end
@@ -46,17 +47,8 @@ module Labimotion
       namespace :get_all_vocabularies do
         desc 'get all standard layers for designer'
         get do
-          # merged_data = []
-          # Dir.glob(Rails.public_path.join('generic', 'vocabularies', '*.json')).each do |file_path|
-          #   file_content = File.read(file_path)
-          #   json_data = JSON.parse(file_content)
-          #   merged_data.concat(json_data)
-          # end
-
-          # list = Labimotion::Vocabulary.all.sort_by { |e| e.name }
-          # present list, with: Labimotion::StdLayer, root: 'klass'
+          authenticate_admin!('vocabularies')
           combined_data = Labimotion::VocabularyHandler.load_all_vocabularies
-          # combined_data = Labimotion::VocabularyEntity.represent(vocabularies, serializable: true)
           return { mc: 'ss00', data: combined_data }
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)
@@ -67,15 +59,9 @@ module Labimotion
       namespace :field_klasses do
         desc 'get all field klasses for admin function'
         get do
-          # Dir.glob(Rails.public_path.join('generic', 'vocabularies', '*.json')).each do |file_path|
-          #   file_content = File.read(file_path)
-          #   json_data = JSON.parse(file_content)
-          #   merged_data.concat(json_data)
-          # end
+          authenticate_admin!('vocabularies')
           vocabularies = Labimotion::VocabularyHandler.load_app_vocabularies
           merged_data = Labimotion::FieldKlassEntity.represent(vocabularies, serializable: true)
-          # list = Labimotion::Vocabulary.all.sort_by { |e| e.name }
-          # present list, with: Labimotion::VocabularyEntity, root: 'klass'
           merged_data
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)
@@ -90,7 +76,7 @@ module Labimotion
         end
         route_param :id do
           before do
-            # error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, Vocabulary.find(params[:id])).destroy?
+            authenticate_admin!('vocabularies')
           end
           delete do
             entity = Labimotion::Vocabulary.find(params[:id])

data/lib/labimotion/constants.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Labimotion
+  module Constants
+    module DateTime
+      DATE_FORMAT = '%Y-%m-%d'
+      DATETIME_FORMAT = '%Y-%m-%d %H:%M:%S %Z'
+      TIME_FORMAT = '%H:%M:%S %Z'
+      TIME_ZONE = 'UTC'
+    end
+
+    module File
+      ENCODING = 'UTF-8'
+    end
+
+    module Mapper
+      NMR_CONFIG = ::File.join(__dir__, 'libs', 'data', 'mapper', 'Source.json').freeze
+    end
+  end
+end

data/lib/labimotion/entities/dataset_entity.rb

@@ -12,6 +12,5 @@ module Labimotion
     def klass_label
       object&.dataset_klass&.label
     end
-
   end
 end

data/lib/labimotion/entities/element_entity.rb

@@ -20,6 +20,7 @@ module Labimotion
       expose! :thumb_svg
       expose! :type
       expose! :uuid
+      expose! :user_labels
     end
 
     with_options(anonymize_below: 10) do

data/lib/labimotion/entities/segment_entity.rb

@@ -9,7 +9,5 @@ module Labimotion
     def klass_label
       object.segment_klass.label
     end
-
-
   end
 end

data/lib/labimotion/entities/vocabulary_entity.rb

@@ -6,16 +6,6 @@ module Labimotion
   class VocabularyEntity < ApplicationEntity
     expose :id, :identifier, :name, :label, :field_type, :opid, :term_id,
            :field_id, :properties, :source, :source_id, :layer_id
-    # expose :source do |obj|
-    #   (obj[:properties] && obj[:properties]['voc'] && obj[:properties]['voc']['source']) || ''
-    # end
-    # expose :source_id do |obj|
-    #   (obj[:properties] && obj[:properties]['voc'] && obj[:properties]['voc']['source_id']) || ''
-    # end
-    # expose :layer_id do |obj|
-    #   (obj[:properties] && obj[:properties]['voc'] && obj[:properties]['voc']['layer_id']) || ''
-    # end
-
     expose :voc do |obj|
       voc = (obj[:properties] && obj[:properties]['voc']) || {}
 

data/lib/labimotion/helpers/generic_helpers.rb

@@ -9,7 +9,12 @@ module Labimotion
     extend Grape::API::Helpers
 
     def authenticate_admin!(type)
-      error!('401 Unauthorized', 401) unless current_user.generic_admin[type]
+      unauthorized = -> { error!('401 Unauthorized', 401) }
+      if %w[standard_layers vocabularies].include?(type)
+        unauthorized.call unless current_user.generic_admin.values_at('elements', 'segments', 'datasets').any?
+      else
+        unauthorized.call unless current_user.generic_admin[type]
+      end
     end
 
     def fetch_klass(name, id)

data/lib/labimotion/helpers/param_helpers.rb

@@ -134,21 +134,5 @@ module Labimotion
       optional :select_options, type: Hash, desc: 'selections'
       optional :option_layers, type: String, desc: 'option'
     end
-
-    # params :vocabulary_save do
-    #   requires :type, type: String, desc: 'type'
-    #   requires :field, type: String, desc: 'field'
-    #   optional :default, type: String, desc: 'default'
-    #   optional :description, type: String, desc: 'description'
-    #   optional :label, type: String, desc: 'label'
-    #   optional :position, type: Integer, desc: 'position'
-    #   optional :ontology, type: Hash, desc: 'ontology'
-    #   optional :required, type: Boolean, desc: 'is required?'
-    #   optional :sub_fields, type: Array, desc: 'sub_fields'
-    #   optional :text_sub_fields, type: Array, desc: 'text_sub_fields'
-    #   optional :source_type, type: String, desc: 'source type'
-    #   optional :source_id, type: String, desc: 'source id'
-    #   optional :layer_id, type: String, desc: 'layer id'
-    # end
   end
 end

data/lib/labimotion/libs/converter.rb

@@ -123,7 +123,6 @@ module Labimotion
         tmp_file.write(response.parsed_response)
         tmp_file.rewind
 
-        # name = response&.headers && response&.headers['content-disposition']&.split('=')&.last
         filename = oat.filename
         name = "#{File.basename(filename, '.*')}.zip"
         att = Attachment.new(

data/lib/labimotion/libs/data/mapper/Source.json

@@ -0,0 +1,78 @@
+{
+  "sourceMap": {
+    "sourceSelector": [
+      "parm",
+      "acqus",
+      "procs"
+    ],
+    "acqus": {
+      "file": "acqus",
+      "parameters": [
+        "DATE",
+        "D1",
+        "INSTRUM",
+        "NS",
+        "NUC1",
+        "NUC2",
+        "PROBHD",
+        "PULPROG",
+        "SFO1",
+        "SFO2",
+        "SOLVENT",
+        "SW",
+        "TD",
+        "TE",
+        "TITLE"
+      ]
+    },
+    "procs": {
+      "file": "pdata/1/procs",
+      "parameters": [
+        "SI",
+        "SF",
+        "WDW",
+        "LB",
+        "GB"
+      ]
+    },
+    "parm": {
+      "file": "pdata/1/parm.txt",
+      "parameters": [
+        "Date_",
+        "Time",
+        "INSTRUM",
+        "PROBHD",
+        "SOLVENT",
+        "TE",
+        "NS",
+        "PULPROG",
+        "TD",
+        "D1",
+        "SF",
+        "SFO1",
+        "SFO2",
+        "NUC1",
+        "NUC2"
+      ]
+    },
+    "parameters": {
+      "DATE": "general.date",
+      "D1": "set.done",
+      "INSTRUM": "instrument.instrument",
+      "NS": "set.ns",
+      "NUC1": "set.nucone",
+      "NUC2": "set.nuctwo",
+      "SF": "set.sf",
+      "SFO1": "set.sfoone",
+      "SFO2": "set.sfotwo",
+      "PROBHD": "equipment.probehead",
+      "PULPROG": "set.PULPROG",
+      "SOLVENT": "sample_preparation.solvent",
+      "TD": "set.td",
+      "TE": "set.temperature",
+      "TITLE": "software.Name",
+      "Version": "software.Version",
+      "Time": "general.time"
+    }
+  }
+}

data/lib/labimotion/libs/dataset_builder.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'labimotion/utils/utils'
+require 'labimotion/version'
+
+module Labimotion
+  class DatasetBuilder
+    def self.build(container, content)
+      return unless valid_input?(container, content)
+
+      create_dataset_with_metadata(container, content)
+    end
+
+    private
+
+    def self.valid_input?(container, content)
+      container.present? &&
+        content.present? &&
+        content[:ols].present? &&
+        content[:metadata].present?
+    end
+
+    def self.create_dataset_with_metadata(container, content)
+      klass = find_dataset_klass(content[:ols])
+      return unless klass
+
+      dataset = create_dataset(container, klass)
+      build_result(dataset, content)
+    end
+
+    def self.find_dataset_klass(ols_term_id)
+      Labimotion::DatasetKlass.find_by(ols_term_id: ols_term_id)
+    end
+
+    def self.create_dataset(container, klass)
+      uuid = SecureRandom.uuid
+      props = prepare_properties(klass, uuid)
+
+      Labimotion::Dataset.create!(
+        uuid: uuid,
+        dataset_klass_id: klass.id,
+        element_type: 'Container',
+        element_id: container.id,
+        properties: props,
+        properties_release: klass.properties_release,
+        klass_uuid: klass.uuid
+      )
+    end
+
+    def self.prepare_properties(klass, uuid)
+      props = klass.properties_release
+      props['uuid'] = uuid
+      props['pkg'] = Labimotion::Utils.pkg(props['pkg'])
+      props['klass'] = 'Dataset'
+      props
+    end
+
+    def self.build_result(dataset, content)
+      {
+        dataset: dataset,
+        metadata: content[:metadata],
+        ols: content[:ols],
+        parameters: content[:parameters]
+      }
+    end
+
+    private_class_method :valid_input?, :create_dataset_with_metadata, :find_dataset_klass, :create_dataset,
+                         :prepare_properties, :build_result
+  end
+end

data/lib/labimotion/libs/nmr_mapper.rb

@@ -1,301 +1,266 @@
 # frozen_string_literal: true
 
+require 'labimotion/libs/dataset_builder'
 require 'labimotion/version'
+require 'labimotion/utils/mapper_utils'
 require 'labimotion/utils/utils'
 
 module Labimotion
   ## NmrMapper
   class NmrMapper
-    def self.process_ds(id, current_user = {})
-      att = Attachment.find_by(id: id, con_state: Labimotion::ConState::NMR)
-      return if att.nil?
-
-      result = is_brucker_binary(id)
-      if result[:is_bagit] == true
-        att.update_column(:con_state, Labimotion::ConState::CONVERTED)
-        Labimotion::Converter.metadata(id, current_user)
-        Labimotion::ConState::COMPLETED
-      elsif result[:metadata] == nil
-        Labimotion::ConState::NONE
-      else
-        ds = Container.find_by(id: att.attachable_id)
-        return if ds.nil? || ds.parent&.container_type != 'analysis'
-
-        data = process(att, id, result[:metadata])
-        generate_ds(id, att.attachable_id, data, current_user)
-        Labimotion::ConState::COMPLETED
+    # Constants specific to NMR mapping
+    module Constants
+      # Duplicate fields that need special handling
+      DUP_FIELDS = %w[time version].freeze
+
+      # Field groups for different processing stages
+      FG_FINALIZE = %w[set.temperature general.date general.time software.Name software.Version].freeze
+      FG_SYSTEM = %w[general.creator sample_details.label sample_details.id].freeze
+
+      # Valid NMR nuclei types
+      OBSERVED = %w[1H 13C].freeze
+
+      # OLS terms for different NMR types
+      module OlsTerms
+        NMR_1H = 'CHMO:0000593'
+        NMR_13C = 'CHMO:0000595'
       end
     end
 
-    def self.is_brucker_binary(id)
-      att = Attachment.find_by(id: id, con_state: Labimotion::ConState::NMR)
-      return if att.nil?
-
-      if att&.attachment_attacher&.file&.url
-        Zip::File.open(att.attachment_attacher.file.url) do |zip_file|
-          zip_file.each do |entry|
-            if entry.name.include?('/pdata/') && entry.name.include?('parm.txt')
-              metadata = entry.get_input_stream.read.force_encoding('UTF-8')
-              return { is_bagit: false, metadata: metadata }
-            elsif entry.name.include?('metadata/') && entry.name.include?('converter.json')
-              return { is_bagit: true, metadata: nil }
-            end
-          end
-        end
-      end
-      { is_bagit: false, metadata: nil }
-    end
+    class << self
+      def process_ds(id, current_user = {})
+        att = find_attachment(id)
+        return Labimotion::ConState::NONE if att.nil?
 
-    def self.process(att, id, content)
-      return if att.nil? || content.nil?
+        result = process(att)
+        return Labimotion::ConState::NONE if result.nil?
 
-      lines = content.split("\n").reject(&:empty?)
-      metadata = {}
-      lines.map do |ln|
-        arr = ln.split(/\s+/)
-        metadata[arr[0]] = arr[1..-1].join(' ') if arr.length > 1
+        handle_process_result(result, att, id, current_user)
       end
-      ols = 'CHMO:0000593' if metadata['NUC1'] == '1H'
-      ols = 'CHMO:0000595' if metadata['NUC1'] == '13C'
-
-      { content: { metadata: metadata, ols: ols } }
-      # if content.present? && att.present?
-      #   Labimotion::NmrMapper.ts('write', att.attachable_id,
-      #                         content: { metadata: metadata, ols: ols })
-      # end
-    end
 
-    def self.fetch_content(id)
-      atts = Attachment.where(attachable_id: id)
-      return if atts.nil?
+      def process(att)
+        config = Labimotion::MapperUtils.load_brucker_config
+        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?
 
-      atts.each do |att|
-        content = Labimotion::NmrMapper.ts('read', att.id)
-        return content if content.present?
+        extracted_data[:parameters] = config['sourceMap']['parameters']
+        extracted_data
       end
-    end
 
+      def generate_ds(_id, cid, data, current_user = {}, element = nil)
+        return if data.nil? || cid.nil?
 
-    def self.generate_ds(id, cid, data, current_user = {})
-      return if data.nil? || cid.nil?
+        obj = Labimotion::NmrMapper.build_ds(cid, data[:content])
+        return if obj.nil? || obj[:ols].nil?
 
-      obj = Labimotion::NmrMapper.build_ds(cid, data[:content])
-      return if obj.nil? || obj[:ols].nil?
+        Labimotion::NmrMapper.update_ds(cid, obj, current_user, element)
+      end
 
-      Labimotion::NmrMapper.update_ds_1h(cid, obj, current_user) if obj[:ols] == 'CHMO:0000593'
-      Labimotion::NmrMapper.update_ds_1h(cid, obj, current_user) if obj[:ols] == 'CHMO:0000595'
-    end
+      def update_ds(_cid, obj, current_user, element)
+        dataset = obj[:dataset]
+        dataset.properties = process_prop(obj, current_user, element)
+        dataset.save!
+      end
 
-    def self.update_ds_13c(id, obj)
-      # dataset = obj[:dataset]
-      # metadata = obj[:metadata]
-      # new_prop = dataset.properties
+      def build_ds(id, content)
+        ds = find_container(id)
+        return if ds.nil? || content.nil?
 
-      # dataset.properties = new_prop
-      # dataset.save!
-    end
+        Labimotion::DatasetBuilder.build(ds, content)
+      end
 
-    def self.set_data(prop, field, idx, layer_name, field_name, value)
-      return if field['field'] != field_name || value&.empty?
+      private
 
-      field['value'] = value
-      prop[Labimotion::Prop::LAYERS][layer_name][Labimotion::Prop::FIELDS][idx] = field
-      prop
-    end
+      def finalize_ds(new_prop)
+        Constants::FG_FINALIZE.each do |field_path|
+          field = find_field(new_prop, field_path)
+          next unless field
 
-    def self.update_ds_1h(id, obj, current_user)
-      dataset = obj[:dataset]
-      metadata = obj[:metadata]
-      new_prop = dataset.properties
-      new_prop.dig(Labimotion::Prop::LAYERS, 'general', Labimotion::Prop::FIELDS)&.each_with_index do |fi, idx|
-        #  new_prop = set_data(new_prop, fi, idx, 'general', 'title', metadata['NAME'])
-        if fi['field'] == 'title' && metadata['NAME'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['NAME']
-          fi['device'] = metadata['NAME']
-          fi['dkey'] = 'NAME'
-          new_prop[Labimotion::Prop::LAYERS]['general'][Labimotion::Prop::FIELDS][idx] = fi
+          update_finalized_field(field)
         end
+        new_prop
+      end
 
-        if fi['field'] == 'date' && metadata['Date_'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['Date_']
-          fi['device'] = metadata['Date_']
-          fi['dkey'] = 'Date_'
-          new_prop[Labimotion::Prop::LAYERS]['general'][Labimotion::Prop::FIELDS][idx] = fi
-        end
+      def sys_to_ds(new_prop, element, current_user)
+        Constants::FG_SYSTEM.each do |field_path|
+          field = find_field(new_prop, field_path)
+          next unless field
 
-        if fi['field'] == 'time' && metadata['Time'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['Time']
-          fi['device'] = metadata['Time']
-          fi['dkey'] = 'Time'
-          new_prop[Labimotion::Prop::LAYERS]['general'][Labimotion::Prop::FIELDS][idx] = fi
+          update_system_field(field, current_user, element)
         end
+        new_prop
+      end
+
+      def params_to_ds(obj, new_prop)
+        metadata = obj[:metadata]
+        parameters = obj[:parameters]
+
+        parameters.each do |param_key, field_path|
+          next if skip_parameter?(metadata, param_key)
 
-        if fi['field'] == 'creator' && current_user.present?
-          ## fi['label'] = fi['label']
-          fi['value'] = current_user.name
-          new_prop[Labimotion::Prop::LAYERS]['general'][Labimotion::Prop::FIELDS][idx] = fi
+          update_param_field(new_prop, field_path, param_key, metadata)
         end
+        new_prop
       end
-      element = Container.find(id)&.root_element
-      element.present? && element&.class&.name == 'Sample' && new_prop.dig(Labimotion::Prop::LAYERS, 'sample_details',
-                                                                          Labimotion::Prop::FIELDS)&.each_with_index do |fi, idx|
-        if fi['field'] == 'label'
-          fi['value'] = element.short_label
-          new_prop[Labimotion::Prop::LAYERS]['sample_details'][Labimotion::Prop::FIELDS][idx] = fi
-        end
-        if fi['field'] == 'id'
-          fi['value'] = element.id
-          new_prop[Labimotion::Prop::LAYERS]['sample_details'][Labimotion::Prop::FIELDS][idx] = fi
-        end
+
+      def process_prop(obj, current_user, element)
+        new_prop = obj[:dataset].properties
+        new_prop
+          .then { |prop| params_to_ds(obj, prop) }
+          .then { |prop| sys_to_ds(prop, element, current_user) }
+          .then { |prop| finalize_ds(prop) }
+          .then { |prop| Labimotion::VocabularyHandler.update_vocabularies(prop, current_user, element) }
       end
 
-      new_prop.dig(Labimotion::Prop::LAYERS, 'instrument', Labimotion::Prop::FIELDS)&.each_with_index do |fi, idx|
-        if fi['field'] == 'instrument' && metadata['INSTRUM'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['INSTRUM']
-          fi['device'] = metadata['INSTRUM']
-          fi['dkey'] = 'INSTRUM'
-          new_prop[Labimotion::Prop::LAYERS]['instrument'][Labimotion::Prop::FIELDS][idx] = fi
-        end
+      def find_attachment(id)
+        Attachment.find_by(id: id, con_state: Labimotion::ConState::NMR)
       end
 
-      new_prop.dig(Labimotion::Prop::LAYERS, 'equipment', Labimotion::Prop::FIELDS)&.each_with_index do |fi, idx|
-        if fi['field'] == 'probehead' && metadata['PROBHD'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['PROBHD']
-          fi['device'] = metadata['PROBHD']
-          fi['dkey'] = 'PROBHD'
-          new_prop[Labimotion::Prop::LAYERS]['equipment'][Labimotion::Prop::FIELDS][idx] = fi
+      def handle_process_result(result, att, id, current_user)
+        if result[:is_bagit]
+          handle_bagit_result(att, id, current_user)
+        elsif invalid_metadata?(result)
+          Labimotion::ConState::NONE
+        else
+          handle_nmr_result(result, att, current_user)
         end
       end
 
-      new_prop.dig(Labimotion::Prop::LAYERS, 'sample_preparation', Labimotion::Prop::FIELDS)&.each_with_index do |fi, idx|
-        if fi['field'] == 'solvent' && metadata['SOLVENT'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['SOLVENT']
-          fi['device'] = metadata['SOLVENT']
-          fi['dkey'] = 'SOLVENT'
-          fi['value'] = 'chloroform-D1 (CDCl3)' if metadata['SOLVENT'] == 'CDCl3'
-          new_prop[Labimotion::Prop::LAYERS]['sample_preparation'][Labimotion::Prop::FIELDS][idx] = fi
-        end
+      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
       end
 
-      new_prop.dig(Labimotion::Prop::LAYERS, 'set', Labimotion::Prop::FIELDS)&.each_with_index do |fi, idx|
-        if fi['field'] == 'temperature' && metadata['TE'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['TE'].split(/\s+/).first
-          fi['device'] = metadata['TE']
-          fi['dkey'] = 'TE'
-          fi['value_system'] = metadata['TE'].split(/\s+/).last
-          new_prop[Labimotion::Prop::LAYERS]['set'][Labimotion::Prop::FIELDS][idx] = fi
-        end
-        if fi['field'] == 'ns' && metadata['NS'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['NS']
-          fi['device'] = metadata['NS']
-          fi['dkey'] = 'NS'
-          new_prop[Labimotion::Prop::LAYERS]['set'][Labimotion::Prop::FIELDS][idx] = fi
-        end
-        if fi['field'] == 'PULPROG' && metadata['PULPROG'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['PULPROG']
-          fi['device'] = metadata['PULPROG']
-          fi['dkey'] = 'PULPROG'
-          new_prop[Labimotion::Prop::LAYERS]['set'][Labimotion::Prop::FIELDS][idx] = fi
-        end
-        if fi['field'] == 'td' && metadata['TD'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['TD']
-          fi['device'] = metadata['TD']
-          fi['dkey'] = 'TD'
-          new_prop[Labimotion::Prop::LAYERS]['set'][Labimotion::Prop::FIELDS][idx] = fi
-        end
-        if fi['field'] == 'done' && metadata['D1'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['D1']
-          fi['device'] = metadata['D1']
-          fi['dkey'] = 'D1'
-          new_prop[Labimotion::Prop::LAYERS]['set'][Labimotion::Prop::FIELDS][idx] = fi
-        end
-        if fi['field'] == 'sf' && metadata['SF'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['SF']
-          fi['device'] = metadata['SF']
-          fi['dkey'] = 'SF'
-          new_prop[Labimotion::Prop::LAYERS]['set'][Labimotion::Prop::FIELDS][idx] = fi
+      def invalid_metadata?(result)
+        result[:metadata].nil? ||
+          Constants::OBSERVED.exclude?(result[:metadata]['NUC1'])
+      end
+
+      def handle_nmr_result(result, att, current_user)
+        ds = find_container(att.attachable_id)
+        return Labimotion::ConState::NONE unless valid_container?(ds)
+
+        prepare_mapper_result(ds, result, current_user)
+        Labimotion::ConState::COMPLETED
+      end
+
+      def find_container(cid)
+        Container.find_by(id: cid)
+      end
+
+      def valid_container?(container)
+        container.present? &&
+          container.parent&.container_type == 'analysis' &&
+          container.root_element.present?
+      end
+
+      def prepare_mapper_result(container, result, current_user)
+        metadata = result[:metadata]
+        ols = determine_ols_term(metadata['NUC1'])
+
+        data = {
+          content: {
+            metadata: metadata,
+            ols: ols,
+            parameters: result[:parameters]
+          }
+        }
+
+        generate_ds(nil, container.id, data, current_user, container.root_element)
+      end
+
+      def determine_ols_term(nuc1)
+        case nuc1
+        when '1H' then Constants::OlsTerms::NMR_1H
+        when '13C' then Constants::OlsTerms::NMR_13C
         end
-        if fi['field'] == 'sfoone' && metadata['SFO1'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['SFO1']
-          fi['device'] = metadata['SFO1']
-          fi['dkey'] = 'SFO1'
-          new_prop[Labimotion::Prop::LAYERS]['set'][Labimotion::Prop::FIELDS][idx] = fi
+      end
+
+      def skip_parameter?(metadata, param_key)
+        metadata[param_key.to_s].blank? &&
+          Constants::DUP_FIELDS.exclude?(param_key.to_s.downcase)
+      end
+
+      def find_field(properties, field_path)
+        layer_name, field_name = field_path.split('.')
+        fields = properties.dig(Labimotion::Prop::LAYERS, layer_name, Labimotion::Prop::FIELDS)
+        return unless fields
+
+        fields.find { |f| f['field'] == field_name }
+      end
+
+      def update_param_field(properties, field_path, param_key, metadata)
+        field = find_field(properties, field_path)
+        return unless field
+
+        update_field_value(field, param_key, metadata)
+        update_field_extend(field, param_key, metadata)
+      end
+
+      def update_duplicate_field(field_name, metadata)
+        case field_name
+        when 'time' then metadata['DATE']
+        when 'Version' then metadata['TITLE']
         end
-        if fi['field'] == 'sfotwo' && metadata['SFO2'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['SFO2']
-          fi['device'] = metadata['SFO2']
-          fi['dkey'] = 'SFO2'
-          new_prop[Labimotion::Prop::LAYERS]['set'][Labimotion::Prop::FIELDS][idx] = fi
+      end
+
+      def update_field_value(field, param_key, metadata)
+        field['value'] = format_field_value(field, param_key, metadata)
+      rescue StandardError => e
+        Rails.logger.error "Error converting value for #{param_key}: #{e.message}"
+        field['value'] = ''
+      end
+
+      def format_field_value(field, param_key, metadata)
+        if field['type'] == 'integer'
+          Integer(metadata[param_key.to_s])
+        elsif Constants::DUP_FIELDS.include?(param_key.to_s.downcase)
+          update_duplicate_field(field['field'], metadata)
+        else
+          metadata[param_key.to_s]
         end
-        if fi['field'] == 'nucone' && metadata['NUC1'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['NUC1']
-          fi['device'] = metadata['NUC1']
-          fi['dkey'] = 'NUC1'
-          new_prop[Labimotion::Prop::LAYERS]['set'][Labimotion::Prop::FIELDS][idx] = fi
+      end
+
+      def update_finalized_field(field)
+        case field['field']
+        when 'temperature'
+          field['value_system'] = 'K'
+        when 'date', 'time'
+          field['value'] = Labimotion::MapperUtils.format_timestamp(field['value'], field['field'])
+        when 'Name'
+          field['value'] = 'TopSpin' if field['value'].to_s.include?('TopSpin')
+        when 'Version'
+          field['value'] = field['value'].to_s.split('TopSpin').last.strip if field['value'].to_s.include?('TopSpin')
         end
-        if fi['field'] == 'nuctwo' && metadata['NUC2'].present?
-          ## fi['label'] = fi['label']
-          fi['value'] = metadata['NUC2']
-          fi['device'] = metadata['NUC2']
-          fi['dkey'] = 'NUC2'
-          new_prop[Labimotion::Prop::LAYERS]['set'][Labimotion::Prop::FIELDS][idx] = fi
+      end
+
+      def update_system_field(field, current_user, element)
+        field['value'] = determine_field_value(field['field'], current_user, element)
+      end
+
+      def determine_field_value(field_name, current_user, element)
+        case field_name
+        when 'creator'
+          current_user&.name if current_user.present?
+        when 'label', 'id'
+          get_sample_value(field_name, element)
         end
       end
-      new_prop = Labimotion::VocabularyHandler.update_vocabularies(new_prop, current_user, element)
-      dataset.properties = new_prop
-      dataset.save!
-    end
 
-    def self.ts(method, identifier, params = nil)
-      Rails.cache.send(method, "#{Labimotion::NmrMapper.new.class.name}#{identifier}", params)
-    end
+      def get_sample_value(field_name, element)
+        return unless element.present? && element.is_a?(Sample)
 
-    def self.clean(id)
-      Labimotion::NmrMapper.ts('delete', id)
-    end
+        field_name == 'label' ? element.short_label : element.id
+      end
 
-    def self.build_ds(id, content)
-      ds = Container.find_by(id: id)
-      return if ds.nil? || content.nil?
-
-      ols = content[:ols]
-      metadata = content[:metadata]
-
-      return if ols.nil? || metadata.nil?
-
-      klass = Labimotion::DatasetKlass.find_by(ols_term_id: ols)
-      return if klass.nil?
-
-      uuid = SecureRandom.uuid
-      props = klass.properties_release
-      props['uuid'] = uuid
-      props['pkg'] = Labimotion::Utils.pkg(props['pkg'])
-      props['klass'] = 'Dataset'
-      dataset = Labimotion::Dataset.create!(
-        uuid: uuid,
-        dataset_klass_id: klass.id,
-        element_type: 'Container',
-        element_id: ds.id,
-        properties: props,
-        properties_release: klass.properties_release,
-        klass_uuid: klass.uuid,
-      )
-      { dataset: dataset, metadata: metadata, ols: ols }
+      def update_field_extend(field, param_key, metadata)
+        field['device'] = metadata[param_key.to_s]
+        field['dkey'] = param_key.to_s
+      end
     end
   end
 end

data/lib/labimotion/utils/mapper_utils.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+require 'zip'
+require 'labimotion/constants'
+
+module Labimotion
+  class MapperUtils
+    class << self
+      def load_config(config_json)
+        JSON.parse(config_json)
+      rescue JSON::ParserError => e
+        Rails.logger.error "Error parsing JSON: #{e.message}"
+        nil
+      rescue Errno::ENOENT => e
+        Rails.logger.error "Config file not found at #{Constants::Mapper::NMR_CONFIG}: #{e.message}"
+        nil
+      rescue StandardError => e
+        Rails.logger.error "Unexpected error loading config: #{e.message}"
+        nil
+      end
+
+      def load_brucker_config
+        config = load_config(File.read(Constants::Mapper::NMR_CONFIG))
+        return if config.nil? || config['sourceMap'].nil?
+
+        source_selector = config['sourceMap']['sourceSelector']
+        return if source_selector.blank?
+
+        parameters = config['sourceMap']['parameters']
+        return if parameters.blank?
+
+        config
+      end
+
+      def extract_data_from_zip(zip_file_url, source_map)
+        return nil if zip_file_url.nil?
+
+        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 extract_parameters(file_content, parameter_names)
+        return nil if file_content.blank? || parameter_names.blank?
+
+        patterns = {
+          standard: build_parameter_pattern(parameter_names, :standard),
+          parm: build_parameter_pattern(parameter_names, :parm)
+        }
+
+        extracted_parameters = {}
+        begin
+          file_content.each_line do |line|
+            if (match = match_parameter(line, patterns))
+              value = clean_value(match[:value])
+              extracted_parameters[match[:param_name]] = value
+            end
+          end
+        rescue StandardError => e
+          Rails.logger.error "Error reading file content: #{e.message}"
+          return nil
+        end
+        extracted_parameters.compact_blank!
+        extracted_parameters
+      end
+
+      def format_timestamp(timestamp_str, give_format = nil)
+        return nil if timestamp_str.blank?
+
+        begin
+          timestamp = Integer(timestamp_str)
+          time_object = Time.at(timestamp).in_time_zone(Constants::DateTime::TIME_ZONE)
+          case give_format
+          when 'date'
+            time_object.strftime(Constants::DateTime::DATE_FORMAT)
+          when 'time'
+            time_object.strftime(Constants::DateTime::TIME_FORMAT)
+          else
+            time_object.strftime(Constants::DateTime::DATETIME_FORMAT)
+          end
+        rescue ArgumentError, TypeError => e
+          Rails.logger.error "Error parsing timestamp '#{timestamp_str}': #{e.message}"
+          nil
+        end
+      end
+
+      private
+
+      def build_parameter_pattern(parameter_names, format)
+        pattern = case format
+                  when :standard
+                    '^\\s*##?\\s*[$]?(?<param_name>%s)\\s*(?:=\\s*)?(?<value>.*?)\\s*$'
+                  when :parm
+                    '^\\s*(?<param_name>%s)\\s+(?<value>[^\\s].*?)(?:\\s+[A-Za-z]+)?\\s*$'
+                  end
+
+        param_regex = parameter_names.map { |p| "\\b#{Regexp.escape(p)}\\b" }.join('|')
+        Regexp.new(pattern % param_regex)
+      end
+
+      def match_parameter(line, patterns)
+        patterns.each_value do |pattern|
+          match = line.match(pattern)
+          return match if match
+        end
+        nil
+      end
+
+      def clean_value(value)
+        value = value.strip
+        value = value[1..-2].strip if value.start_with?('<') && value.end_with?('>')
+        value
+      end
+
+      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
+        end
+
+        return { is_bagit: false, metadata: final_parameters } if final_parameters.present?
+
+        nil
+      end
+
+      def process_source(zip_file, source_config, final_parameters)
+        return if invalid_source_config?(source_config)
+
+        zip_file.each do |entry|
+          if source_file?(entry, source_config)
+            process_file_entry(entry, source_config['parameters'], final_parameters)
+          elsif bagit_metadata_file?(entry)
+            return { is_bagit: true, metadata: nil }
+          end
+        end
+      end
+
+      def process_file_entry(entry, parameters, final_parameters)
+        file_content = entry.get_input_stream.read.force_encoding(Constants::File::ENCODING)
+        extracted_parameters = extract_parameters(file_content, parameters)
+        final_parameters.merge!(extracted_parameters) if extracted_parameters.present?
+      end
+
+      def invalid_source_config?(source_config)
+        source_config.nil? ||
+          source_config['file'].nil? ||
+          source_config['parameters'].nil?
+      end
+
+      def source_file?(entry, source_config)
+        entry.name.include?(source_config['file'])
+      end
+
+      def bagit_metadata_file?(entry)
+        entry.name.include?('metadata/') &&
+          entry.name.include?('converter.json')
+      end
+    end
+  end
+end

data/lib/labimotion/version.rb

@@ -2,5 +2,5 @@
 
 ## Labimotion Version
 module Labimotion
-  VERSION = '2.0.0.rc1'
+  VERSION = '2.0.0.rc3'
 end

data/lib/labimotion.rb

@@ -1,8 +1,8 @@
 # In your_gem_name.rb or main Ruby file
 module Labimotion
-
   autoload :CONF, 'labimotion/conf'
   autoload :VERSION, 'labimotion/version'
+  autoload :Constants, 'labimotion/constants'
 
   def self.logger
     @@labimotion_logger ||= Logger.new(Rails.root.join('log/labimotion.log')) # rubocop:disable Style/ClassVars
@@ -13,6 +13,7 @@ module Labimotion
     Labimotion.logger.error(exception.backtrace.join("\n"))
   end
 
+  autoload :MapperUtils, 'labimotion/utils/mapper_utils'
   autoload :Utils, 'labimotion/utils/utils'
 
   ######## APIs
@@ -62,6 +63,7 @@ module Labimotion
 
   ######## Libs
   autoload :Converter, 'labimotion/libs/converter'
+  autoload :DatasetBuilder, 'labimotion/libs/dataset_builder'
   autoload :NmrMapper, 'labimotion/libs/nmr_mapper'
   autoload :NmrMapperRepo, 'labimotion/libs/nmr_mapper_repo' ## for Chemotion Repository
   autoload :TemplateHub, 'labimotion/libs/template_hub'
@@ -114,6 +116,4 @@ module Labimotion
   autoload :Datasetable, 'labimotion/models/concerns/datasetable'
   autoload :AttachmentConverter, 'labimotion/models/concerns/attachment_converter.rb'
   autoload :LinkedProperties, 'labimotion/models/concerns/linked_properties'
-
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc1
+  version: 2.0.0.rc3
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-12-06 00:00:00.000000000 Z
+date: 2025-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -47,6 +47,7 @@ files:
 - lib/labimotion/collection/export.rb
 - lib/labimotion/collection/import.rb
 - lib/labimotion/conf.rb
+- lib/labimotion/constants.rb
 - lib/labimotion/entities/application_entity.rb
 - lib/labimotion/entities/dataset_entity.rb
 - lib/labimotion/entities/dataset_klass_entity.rb
@@ -75,8 +76,10 @@ files:
 - lib/labimotion/helpers/vocabulary_helpers.rb
 - lib/labimotion/libs/attachment_handler.rb
 - lib/labimotion/libs/converter.rb
+- lib/labimotion/libs/data/mapper/Source.json
 - lib/labimotion/libs/data/vocab/Standard.json
 - lib/labimotion/libs/data/vocab/System.json
+- lib/labimotion/libs/dataset_builder.rb
 - lib/labimotion/libs/export_dataset.rb
 - lib/labimotion/libs/export_element.rb
 - lib/labimotion/libs/nmr_mapper.rb
@@ -114,6 +117,7 @@ files:
 - lib/labimotion/utils/export_utils.rb
 - lib/labimotion/utils/field_type.rb
 - lib/labimotion/utils/import_utils.rb
+- lib/labimotion/utils/mapper_utils.rb
 - lib/labimotion/utils/prop.rb
 - lib/labimotion/utils/search.rb
 - lib/labimotion/utils/serializer.rb