labimotion 1.5.0.rc7 → 1.5.0.rc8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 933a7ef2942093d53c89df803dd802efeb4f0a0241193de7094d51c26fcfa8ff
-  data.tar.gz: 5792273bc537ccf951ee3c7ab5ef575f23079b63acc8ce3f2d923fb445181d26
+  metadata.gz: 5a54a18e3c64bb9446ecf6c57aa2755d9ab0921a2571aa734615faa40f46d19d
+  data.tar.gz: 03a66fbf2e025ac855831349888ab941b7a2059a02557c473c4654eaceb62601
 SHA512:
-  metadata.gz: 2b50364418e278a654814ef2afa8c29bf2c9a2a1d4d134fb690573e317676b2fe9cdfa2afbc5cce8d65a5317fcf45a7f7a427791c36b19cc3f4d85a043055048
-  data.tar.gz: 04a7949b73b943642f8c2e4e4541d4ee3695e27aded5fc447818c5bfaefd2ba8ced4626f9bd045eef9765fe75c7d5f42016f1afe2b202cd0454bcd5be89c94fe
+  metadata.gz: fb9af61e157bc3c89b8b32d3fe51aa580d6a684c8348029e6b291e65d0f1876f48279f09bd291dc40194cb2a1c84cc84c6ea3beac5092f34ce1b2d6fd64db52b
+  data.tar.gz: cde31727f46f71e4803cc933f56e1f73785f87f9ab928a010299dc7c33dbdd504907cc31aa73bdc81000bf1774a60095a23860ae4e7d6b0ffdd29046612615da

data/lib/labimotion/apis/vocabulary_api.rb

@@ -74,10 +74,8 @@ module Labimotion
           # end
           vocabularies = Labimotion::VocabularyHandler.load_app_vocabularies
           merged_data = Labimotion::FieldKlassEntity.represent(vocabularies, serializable: true)
-          # byebug
           # list = Labimotion::Vocabulary.all.sort_by { |e| e.name }
           # present list, with: Labimotion::VocabularyEntity, root: 'klass'
-          # byebug
           merged_data
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)

data/lib/labimotion/entities/dataset_entity.rb

@@ -13,78 +13,5 @@ module Labimotion
       object&.dataset_klass&.label
     end
 
-
-    # def root_element
-    #   object&.element&.root_element
-    # end
-
-#     def properties
-#       prop = object&.properties || {}
-#       prop[Labimotion::Prop::LAYERS].keys.each do |key|
-#         layer = prop[Labimotion::Prop::LAYERS][key] || {}
-#         return prop if layer.empty? || layer[Labimotion::Prop::FIELDS].nil?
-
-#         field_vocs = layer[Labimotion::Prop::FIELDS].select { |ss| ss['is_voc'] == true }
-#         field_vocs.each do |field|
-#           idx = prop[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
-#           next if idx.nil?
-
-#           case field['source']
-#             when Labimotion::Prop::ELEMENT
-#               if field['identifier'] == 'element.name'
-#                 # byebug
-#                 prop[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = root_element&.name
-#               #  dic[field.identifier] = currentElement.name
-
-#               end
-#             when Labimotion::Prop::SEGMENT
-#               segs = root_element&.segments&.select { |ss| field['source_id'] == ss.segment_klass&.identifier }
-#               next if segs.empty? || field['layer_id'].blank? || field['field_id'].blank?
-
-#               seg = segs&.first
-#               seg_fields = seg.properties.dig(Labimotion::Prop::LAYERS, field['layer_id'], Labimotion::Prop::FIELDS).select { |ff| ff['field'] == field['field_id'] }
-#               seg_field = seg_fields&.first
-#               prop[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = seg_field['value']
-#             when Labimotion::Prop::DATASET
-#               # byebug
-#               dk = DatasetKlass.find_by(identifier: field["source_id"])
-#               dk["ols_term_id"]
-#               # byebug
-# #              sel_ana = root_element.analyses.select { |ana| ana.extended_metadata["kind"].split("|")&.first&.strip == dk["ols_term_id"] }
-#               anas = root_element.analyses.select { |ana| ana.extended_metadata["kind"].split("|")&.first&.strip == dk["ols_term_id"] }
-#               anas.each do |ana|
-#                 cdss = ana.children
-#                 cdss.each do |cds|
-#                   next unless cds.dataset.present?
-#                   ds_prop = cds.dataset.properties
-#                   ds_fields = ds_prop.dig(Labimotion::Prop::LAYERS, field['layer_id'], Labimotion::Prop::FIELDS).select { |ff| ff['field'] == field['field_id'] }
-#                   ds_field = ds_fields&.first
-#                  # byebug
-#                   if prop[Labimotion::Prop::LAYERS][key].present? && ds_field['value'].present?
-#                     prop[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = ds_field['value']
-#                   end
-#                 end
-#               end
-
-#               # sel_ana.dataset
-#               # if root_element.analyses&.first&.extended_metadata["kind"].split("|")&.first&.strip == dk["ols_term_id"]
-#               #   byebug
-#               # end
-#               # root_element.analyses.select { |ss| ss.dataset_klass_id == dk.id }
-#             end
-#         end
-
-#         # layer[Labimotion::Prop::FIELDS].each do |field|
-#         # end
-#       end
-
-    #   # byebug
-    #   # layers = properties['layers']
-
-    #   # properties['vocabularies'].each_with_object({}) do |v, h|
-    #   #   h[v['name']] = v['value']
-    #   # end
-    #   prop
-    # end
   end
 end

data/lib/labimotion/entities/properties_entity.rb

@@ -1,109 +1,163 @@
 require 'labimotion/entities/application_entity'
 
-# Entity module
 module Labimotion
   class PropertiesEntity < Labimotion::ApplicationEntity
-
-    # TODO: Refactor this method to something more readable/understandable
     def properties
+      process_layers do |key, layer|
+        process_fields(key, layer)
+      end
+      object.properties
+    end
+
+    private
+
+    def process_layers
       (object&.properties.is_a?(Hash) && object.properties[Labimotion::Prop::LAYERS]&.keys || []).each do |key|
+        yield(key, object.properties[Labimotion::Prop::LAYERS][key])
+      end
+    end
 
+    def process_fields(key, layer)
+      process_sample_and_molecule_fields(key, layer)
+      process_reaction_fields(key, layer)
+      process_table_fields(key, layer)
+      process_voc_fields(key, layer)
+    end
 
-        field_sample_molecules = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_SAMPLE || ss['type'] == Labimotion::FieldType::DRAG_MOLECULE }
-        field_sample_molecules.each do |field|
-          idx = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
-          sid = field.dig('value', 'el_id')
-          next unless sid.present?
+    def process_sample_and_molecule_fields(key, layer)
+      select_fields(layer, [Labimotion::FieldType::DRAG_SAMPLE, Labimotion::FieldType::DRAG_MOLECULE]).each do |field, idx|
+        update_sample_or_molecule_field(key, field, idx)
+      end
+    end
 
-          el = field['type'] == Labimotion::FieldType::DRAG_SAMPLE ? Sample.find_by(id: sid) : Molecule.find_by(id: sid)
-          next unless el.present?
-          next unless object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value').present?
+    def process_reaction_fields(key, layer)
+      select_fields(layer, [Labimotion::FieldType::SYS_REACTION]).each do |field, idx|
+        update_reaction_field(key, field, idx)
+      end
+    end
 
-          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_label'] = el.short_label if field['type'] == Labimotion::FieldType::DRAG_SAMPLE
-          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_tip'] = el.short_label if field['type'] == Labimotion::FieldType::DRAG_SAMPLE
-          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_svg'] = field['type'] == Labimotion::FieldType::DRAG_SAMPLE ? el.get_svg_path : File.join('/images', 'molecules', el&.molecule_svg_file || 'nosvg')
-        end
+    def process_table_fields(key, layer)
+      select_fields(layer, [Labimotion::FieldType::TABLE]).each do |field, idx|
+        update_table_field(key, field, idx)
+      end
+    end
 
-        field_sys_reactions = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::SYS_REACTION }
-        field_sys_reactions.each do |field|
-          idx = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
-          sid = field.dig('value', 'el_id')
-          next unless sid.present?
+    def process_voc_fields(key, layer)
+      select_fields(layer, nil, true).each do |field, idx|
+        update_voc_field(key, field, idx)
+      end
+    end
 
-          el = Reaction.find_by(id: sid)
-          if el.blank?
-            object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_tip'] = 'ERROR'
-            object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_svg'] = ''
-          end
+    def select_fields(layer, types = nil, is_voc = false)
+      fields = layer[Labimotion::Prop::FIELDS]
+      fields = fields.select { |f| types.include?(f['type']) } if types
+      fields = fields.select { |f| f['is_voc'] == true } if is_voc
+      fields.map { |f| [f, fields.index(f)] }
+    end
 
-          next unless el.present?
-          next unless object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value').present?
+    def update_sample_or_molecule_field(key, field, idx)
+      sid = field.dig('value', 'el_id')
+      return unless sid.present?
 
-          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_label'] = el.short_label
-          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_tip'] = el.short_label
-          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_svg'] =  el.reaction_svg_file
-        end
+      el = field['type'] == Labimotion::FieldType::DRAG_SAMPLE ? Sample.find_by(id: sid) : Molecule.find_by(id: sid)
+      return unless el.present? && object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value').present?
 
-        field_tables = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::TABLE }
-        field_tables.each do |field|
-          idx = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
-          next unless field['sub_values'].present? && field[Labimotion::Prop::SUBFIELDS].present?
+      update_field_value(key, idx, {
+        'el_label' => el.short_label,
+        'el_tip' => el.short_label,
+        'el_svg' => field['type'] == Labimotion::FieldType::DRAG_SAMPLE ? el.get_svg_path : File.join('/images', 'molecules', el&.molecule_svg_file || 'nosvg')
+      })
+    end
 
-          field_table_molecules = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_MOLECULE }
-          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] = set_table(field, field_table_molecules, Labimotion::Prop::MOLECULE) if field_table_molecules.present?
+    def update_reaction_field(key, field, idx)
+      sid = field.dig('value', 'el_id')
+      return unless sid.present?
 
-          field_table_samples = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_SAMPLE }
-          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] = set_table(field, field_table_samples, Labimotion::Prop::SAMPLE) if field_table_samples.present?
-        end
+      el = Reaction.find_by(id: sid)
+      if el.blank?
+        update_field_value(key, idx, { 'el_tip' => 'ERROR', 'el_svg' => '' })
+        return
+      end
 
-        field_vocs = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].select { |ss| ss['is_voc'] == true }
-        field_vocs.each do |field|
-          idx = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
-          next if idx.nil?
-
-          case object.class.name
-          when Labimotion::Prop::L_ELEMENT
-            root_element = object
-          when Labimotion::Prop::L_SEGMENT
-            root_element = object&.element
-          when Labimotion::Prop::L_DATASET
-            root_element = object&.element&.root_element
-          end
+      return unless object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value').present?
 
-          case field['source']
-          when Labimotion::Prop::ELEMENT
-            if field['identifier'] == 'element.name'
-              object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = root_element&.name
-            end
-          when Labimotion::Prop::SEGMENT
-            segs = root_element&.segments&.select { |ss| field['source_id'] == ss.segment_klass&.identifier }
-            next if segs.empty? || field['layer_id'].blank? || field['field_id'].blank?
-
-            seg = segs&.first
-            seg_fields = seg.properties.dig(Labimotion::Prop::LAYERS, field['layer_id'], Labimotion::Prop::FIELDS).select { |ff| ff['field'] == field['field_id'] }
-            seg_field = seg_fields&.first
-            object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = seg_field['value']
-          when Labimotion::Prop::DATASET
-            dk = DatasetKlass.find_by(identifier: field["source_id"])
-            dk["ols_term_id"]
-            anas = root_element.analyses.select { |ana| ana.extended_metadata["kind"].split("|")&.first&.strip == dk["ols_term_id"] }
-            anas.each do |ana|
-              cdss = ana.children
-              cdss.each do |cds|
-                next unless cds.dataset.present?
-
-                ds_prop = cds.dataset.properties
-                ds_fields = ds_prop.dig(Labimotion::Prop::LAYERS, field['layer_id'], Labimotion::Prop::FIELDS).select { |ff| ff['field'] == field['field_id'] }
-                ds_field = ds_fields&.first
-                if object.properties[Labimotion::Prop::LAYERS][key].present? && ds_field['value'].present?
-                  object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = ds_field['value']
-                end
-              end
-            end
+      update_field_value(key, idx, {
+        'el_label' => el.short_label,
+        'el_tip' => el.short_label,
+        'el_svg' => el.reaction_svg_file
+      })
+    end
+
+    def update_table_field(key, field, idx)
+      return unless field['sub_values'].present? && field[Labimotion::Prop::SUBFIELDS].present?
+
+      field_table_molecules = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_MOLECULE }
+      object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] = set_table(field, field_table_molecules, Labimotion::Prop::MOLECULE) if field_table_molecules.present?
+
+      field_table_samples = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_SAMPLE }
+      object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] = set_table(field, field_table_samples, Labimotion::Prop::SAMPLE) if field_table_samples.present?
+    end
+
+    def update_voc_field(key, field, idx)
+      root_element = get_root_element
+
+      case field['source']
+      when Labimotion::Prop::ELEMENT
+        update_element_voc_field(key, field, idx, root_element)
+      when Labimotion::Prop::SEGMENT
+        update_segment_voc_field(key, field, idx, root_element)
+      when Labimotion::Prop::DATASET
+        update_dataset_voc_field(key, field, idx, root_element)
+      end
+    end
+
+    def get_root_element
+      case object.class.name
+      when Labimotion::Prop::L_ELEMENT
+        object
+      when Labimotion::Prop::L_SEGMENT
+        object&.element
+      when Labimotion::Prop::L_DATASET
+        object&.element&.root_element
+      end
+    end
+
+    def update_element_voc_field(key, field, idx, root_element)
+      if field['identifier'] == 'element.name'
+        update_field_value(key, idx, root_element&.name)
+      end
+    end
+
+    def update_segment_voc_field(key, field, idx, root_element)
+      segs = root_element&.segments&.select { |ss| field['source_id'] == ss.segment_klass&.identifier }
+      return if segs.empty? || field['layer_id'].blank? || field['field_id'].blank?
+
+      seg = segs&.first
+      seg_fields = seg.properties.dig(Labimotion::Prop::LAYERS, field['layer_id'], Labimotion::Prop::FIELDS).select { |ff| ff['field'] == field['field_id'] }
+      seg_field = seg_fields&.first
+      update_field_value(key, idx, seg_field['value'])
+    end
+
+    def update_dataset_voc_field(key, field, idx, root_element)
+      dk = DatasetKlass.find_by(identifier: field["source_id"])
+      dk["ols_term_id"]
+      anas = root_element.analyses.select { |ana| ana.extended_metadata["kind"].split("|")&.first&.strip == dk["ols_term_id"] }
+      anas.each do |ana|
+        ana.children.each do |cds|
+          next unless cds.dataset.present?
+
+          ds_prop = cds.dataset.properties
+          ds_fields = ds_prop.dig(Labimotion::Prop::LAYERS, field['layer_id'], Labimotion::Prop::FIELDS).select { |ff| ff['field'] == field['field_id'] }
+          ds_field = ds_fields&.first
+          if object.properties[Labimotion::Prop::LAYERS][key].present? && ds_field['value'].present?
+            update_field_value(key, idx, ds_field['value'])
           end
         end
       end
-      object.properties
+    end
+
+    def update_field_value(key, idx, value)
+      object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = value
     end
 
     def set_table(field, field_table_objs, obj)
@@ -117,23 +171,34 @@ module Labimotion
 
           case obj
           when Labimotion::Prop::MOLECULE
-            sub_value[col_id]['value']['el_svg'] = File.join('/images', 'molecules', find_obj.molecule_svg_file) if find_obj&.molecule_svg_file&.present?
-            sub_value[col_id]['value']['el_inchikey'] = find_obj.inchikey
-            sub_value[col_id]['value']['el_smiles'] = find_obj.cano_smiles
-            sub_value[col_id]['value']['el_iupac'] = find_obj.iupac_name
-            sub_value[col_id]['value']['el_molecular_weight'] = find_obj.molecular_weight
+            update_molecule_sub_value(sub_value, col_id, find_obj)
           when Labimotion::Prop::SAMPLE
-            sub_value[col_id]['value']['el_svg'] = find_obj.get_svg_path
-            sub_value[col_id]['value']['el_label'] = find_obj.short_label
-            sub_value[col_id]['value']['el_short_label'] = find_obj.short_label
-            sub_value[col_id]['value']['el_name'] = find_obj.name
-            sub_value[col_id]['value']['el_external_label'] = find_obj.external_label
-            sub_value[col_id]['value']['el_molecular_weight'] = find_obj.decoupled ? find_obj.molecular_mass : find_obj.molecule.molecular_weight
+            update_sample_sub_value(sub_value, col_id, find_obj)
           end
         end
       end
       field
     end
 
+    def update_molecule_sub_value(sub_value, col_id, find_obj)
+      sub_value[col_id]['value'].merge!({
+        'el_svg' => File.join('/images', 'molecules', find_obj.molecule_svg_file),
+        'el_inchikey' => find_obj.inchikey,
+        'el_smiles' => find_obj.cano_smiles,
+        'el_iupac' => find_obj.iupac_name,
+        'el_molecular_weight' => find_obj.molecular_weight
+      })
+    end
+
+    def update_sample_sub_value(sub_value, col_id, find_obj)
+      sub_value[col_id]['value'].merge!({
+        'el_svg' => find_obj.get_svg_path,
+        'el_label' => find_obj.short_label,
+        'el_short_label' => find_obj.short_label,
+        'el_name' => find_obj.name,
+        'el_external_label' => find_obj.external_label,
+        'el_molecular_weight' => find_obj.decoupled ? find_obj.molecular_mass : find_obj.molecule.molecular_weight
+      })
+    end
   end
-end
+end

data/lib/labimotion/entities/vocabulary_entity.rb

@@ -17,13 +17,11 @@ module Labimotion
     # end
 
     expose :voc do |obj|
-      ## byebug
       voc = (obj[:properties] && obj[:properties]['voc']) || {}
 
       case voc['source']
       when Labimotion::Prop::ELEMENT
         if voc['identifier'] == 'element.name'
-          # byebug
           # voc['source_name'] = ElementKlass.find_by(identifier: voc['source_id'])&.name
         end
       when Labimotion::Prop::SEGMENT

data/lib/labimotion/libs/converter.rb

@@ -28,7 +28,7 @@ module Labimotion
       dsr = []
       ols = nil
       Zip::File.open(att.attachment_attacher.file.url) do |zip_file|
-        res = Labimotion::Converter.collect_metadata(zip_file) if att.filename.split('.')&.last == 'zip'
+        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
@@ -92,7 +92,7 @@ module Labimotion
       { a: oa, f: folder }
     end
 
-    def self.collect_metadata(zip_file) # rubocop: disable Metrics/PerceivedComplexity
+    def self.collect_metadata(zip_file, current_user = {}) # rubocop: disable Metrics/PerceivedComplexity
       dsr = []
       ols = nil
       zip_file.each do |entry|
@@ -114,7 +114,7 @@ module Labimotion
       { d: dsr, o: ols }
     end
 
-    def self.handle_response(oat, response) # rubocop: disable Metrics/PerceivedComplexity
+    def self.handle_response(oat, response, current_user = {}) # rubocop: disable Metrics/PerceivedComplexity
       dsr = []
       ols = nil
 
@@ -123,10 +123,9 @@ module Labimotion
         tmp_file.write(response.parsed_response)
         tmp_file.rewind
 
-        name = response&.headers && response&.headers['content-disposition']&.split('=')&.last
+        # name = response&.headers && response&.headers['content-disposition']&.split('=')&.last
         filename = oat.filename
-        name = "#{File.basename(filename, '.*')}.zip" if name.nil?
-
+        name = "#{File.basename(filename, '.*')}.zip"
         att = Attachment.new(
           filename: name,
           file_path: tmp_file.path,
@@ -140,7 +139,7 @@ module Labimotion
 
         att.save! if att.valid?
 
-        process_ds(att.id)
+        process_ds(att.id, current_user)
       rescue StandardError => e
         raise e
       ensure
@@ -148,7 +147,7 @@ module Labimotion
       end
     end
 
-    def self.process(data)
+    def self.process(data, current_user = {}) # rubocop: disable Metrics/PerceivedComplexity
       return data[:a].con_state if data[:a]&.attachable_type != 'Container'
       response = nil
       begin
@@ -165,25 +164,25 @@ module Labimotion
           )
         end
         if response.ok?
-          Labimotion::Converter.handle_response(data[:a], response)
+          Labimotion::Converter.handle_response(data[:a], response, current_user)
           Labimotion::ConState::PROCESSED
         else
           Labimotion::Converter.logger.error ["Converter Response Error: id: [#{data[:a]&.id}], filename: [#{data[:a]&.filename}], response: #{response}"].join($INPUT_RECORD_SEPARATOR)
           Labimotion::ConState::ERROR
         end
       rescue StandardError => e
-        Labimotion::Converter.logger.error ["process fail: #{id}", e.message, *e.backtrace].join($INPUT_RECORD_SEPARATOR)
+        Labimotion::Converter.logger.error ["process fail: #{data[:a]&.id}", e.message, *e.backtrace].join($INPUT_RECORD_SEPARATOR)
         Labimotion::ConState::ERROR
       ensure
         FileUtils.rm_f(ofile)
       end
     end
 
-    def self.jcamp_converter(id)
+    def self.jcamp_converter(id, current_user = {})
       data = Labimotion::Converter.vor_conv(id)
       return if data.nil?
 
-      Labimotion::Converter.process(data)
+      Labimotion::Converter.process(data, current_user)
     rescue StandardError => e
       Labimotion::Converter.logger.error ["jcamp_converter fail: #{id}", e.message, *e.backtrace].join($INPUT_RECORD_SEPARATOR)
       Labimotion::ConState::ERROR
@@ -243,27 +242,7 @@ module Labimotion
         fi['device'] = ds[:device] || ds[:value]
         new_prop[Labimotion::Prop::LAYERS][ds[:layer]][Labimotion::Prop::FIELDS][idx] = fi
       end
-      new_prop.dig(Labimotion::Prop::LAYERS, 'general', Labimotion::Prop::FIELDS)&.each_with_index do |fi, idx|
-        if fi['field'] == 'creator' && current_user.present?
-          fi['value'] = current_user.name
-          fi['system'] = current_user.name
-          new_prop[Labimotion::Prop::LAYERS]['general'][Labimotion::Prop::FIELDS][idx] = fi
-        end
-      end
       element = Container.find(dataset.element_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'] == 'id'
-          fi['value'] = element.id
-          fi['system'] = element.id
-          new_prop[Labimotion::Prop::LAYERS]['sample_details'][Labimotion::Prop::FIELDS][idx] = fi
-        end
-
-        if fi['field'] == 'label'
-          fi['value'] = element.short_label
-          fi['system'] = element.short_label
-          new_prop[Labimotion::Prop::LAYERS]['sample_details'][Labimotion::Prop::FIELDS][idx] = fi
-        end
-      end
       new_prop = Labimotion::VocabularyHandler.update_vocabularies(new_prop, current_user, element)
       dataset.properties = new_prop
       dataset.save!
@@ -326,13 +305,13 @@ module Labimotion
       res
     end
 
-    def self.metadata(id)
+    def self.metadata(id, current_user)
       att = Attachment.find(id)
       return if att.nil? || att.attachable_id.nil? || att.attachable_type != Labimotion::Prop::CONTAINER
 
       ds = Labimotion::Dataset.find_by(element_type: Labimotion::Prop::CONTAINER, element_id: att.attachable_id)
       att.update_column(:con_state, Labimotion::ConState::COMPLETED) if ds.present?
-      process_ds(att.id) if ds.nil?
+      process_ds(att.id, current_user) if ds.nil?
     end
   end
 end

data/lib/labimotion/libs/data/vocab/System.json

@@ -115,5 +115,17 @@
     "voc": {
       "source": "Element"
     }
+  },
+  {
+    "id": 3,
+    "identifier": "element.class",
+    "name": "Element Class",
+    "label": "Element Class",
+    "field_type": "text",
+    "opid": 9,
+    "source": "Element",
+    "voc": {
+      "source": "Element"
+    }
   }
 ]

data/lib/labimotion/libs/nmr_mapper.rb

@@ -13,7 +13,7 @@ module Labimotion
       result = is_brucker_binary(id)
       if result[:is_bagit] == true
         att.update_column(:con_state, Labimotion::ConState::CONVERTED)
-        Labimotion::Converter.metadata(id)
+        Labimotion::Converter.metadata(id, current_user)
         Labimotion::ConState::COMPLETED
       elsif result[:metadata] == nil
         Labimotion::ConState::NONE

data/lib/labimotion/libs/vocabulary_handler.rb

@@ -2,95 +2,111 @@
 
 module Labimotion
   class VocabularyHandler
+    class << self
+      def update_vocabularies(properties, current_user, element)
+        properties[Labimotion::Prop::LAYERS].each do |key, layer|
+          update_layer_vocabularies(layer, key, properties, current_user, element)
+        end
+        properties
+      rescue StandardError => e
+        Labimotion.log_exception(e, current_user)
+        properties
+      end
+
+      def load_all_vocabularies
+        load_from_files + load_from_database
+      end
+
+      def load_app_vocabularies
+        load_from_files
+      end
+
+      private
 
-    def self.update_vocabularies(properties, current_user, element)
-      properties[Labimotion::Prop::LAYERS].keys.each do |key|
-        layer = properties[Labimotion::Prop::LAYERS][key]
-        field_vocabularies = layer[Labimotion::Prop::FIELDS].select { |ss| ss['is_voc'] == true && ss['opid'] == 9}
+      def update_layer_vocabularies(layer, key, properties, current_user, element)
+        field_vocabularies = layer[Labimotion::Prop::FIELDS].select { |field| field['is_voc'] && field['opid'] == 9 }
         field_vocabularies.each do |field|
-          idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
-          val = ''
-          orig_val = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']
-          case field['source']
-          when 'System'
-            val = Time.now.strftime('%d/%m/%Y %H:%M') if field['identifier'] == 'dateTime.update'
-            val = Time.now.strftime('%d/%m/%Y %H:%M') if field['identifier'] == 'dateTime.create' && orig_val.blank?
-          when 'User'
-            val = current_user.name if field['identifier'] == 'user.name' && current_user.present?
-          when 'Element'
-            val = element.id.to_s if field['identifier'] == 'element.id'
-            val = element.short_label if element.has_attribute?(:short_label) && field['identifier'] == 'element.short_label'
-          when 'Segment'
-            segments = element.segments.joins(:segment_klass).find_by('segment_klasses.identifier = ?', field['source_id'])
-            next if segments.nil?
+          idx = layer[Labimotion::Prop::FIELDS].index(field)
+          val = get_vocabulary_value(field, current_user, element)
+          update_field_value(properties, key, idx, val) if val.present?
+        end
+      end
+
+      def get_vocabulary_value(field, current_user, element)
+        case field['source']
+        when 'System'
+          get_system_value(field)
+        when 'User'
+          get_user_value(field, current_user)
+        when 'Element'
+          get_element_value(field, element)
+        when 'Segment'
+          get_segment_value(field, element)
+        when 'Dataset'
+          # TODO: Implement Dataset logic here
+          nil
+        end
+      end
+
+      def get_system_value(field)
+        current_time = Time.now.strftime('%d/%m/%Y %H:%M')
+        case field['identifier']
+        when 'dateTime.update'
+          current_time
+        when 'dateTime.create'
+          current_time if field['value'].blank?
+        end
+      end
+
+      def get_user_value(field, current_user)
+        return current_user.name if field['identifier'] == 'user.name' && current_user.present?
+      end
 
-            seg_prop = segments.properties
-            fields = seg_prop[Labimotion::Prop::LAYERS][field['layer_id']][Labimotion::Prop::FIELDS].select { |ss| ss['field'] == field['field_id'] }
-            val = fields.first['value']
-          when 'Dataset'
-           # byebug
+      def get_element_value(field, element)
+        case field['identifier']
+        when 'element.id'
+          element.id.to_s
+        when 'element.short_label'
+          element.short_label if element.has_attribute?(:short_label)
+        when 'element.class'
+          if element.class.name === 'Labimotion::Element'
+            element.element_klass.label
+          else
+            element.class.name
           end
-          # case field['identifier']
-          # when 'dateTime.now'
-          #   val = Time.now.strftime('%d/%m/%Y %H:%M')
-          # when 'user.name'
-          #   val = current_user.name
-          # when 'element.id'
-          #   val = element.id.to_s
-          # when 'element.short_label'
-          #   val = element.short_label
-          # end
-          # ontology = {
-          #   id: "ncit:class:http://purl.obolibrary.org/obo/#{field['term_id']}",
-          #   iri: "http://purl.obolibrary.org/obo/#{field['term_id']}",
-          #   type: "class",
-          #   label: field['name'],
-          #   obo_id: field['term_id'],
-          #   short_form: field['term_id'],
-          #   description: field['label'],
-          # }
-          # properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['ontology'] = ontology if ontology.present?
-          properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = val if val.present?
-          ## properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['placeholder'] = val if val.present?
         end
       end
-      properties
-    rescue StandardError => e
-      Labimotion.log_exception(e, current_user)
-      properties
-    end
 
-    def self.load_all_vocabularies
-      file_data = load_from_files
-      db_data = load_from_database
-      file_data + db_data
-    end
+      def get_segment_value(field, element)
+        segments = element.segments.joins(:segment_klass).find_by('segment_klasses.identifier = ?', field['source_id'])
+        return if segments.nil?
 
-    def self.load_app_vocabularies
-      load_from_files
-    end
+        seg_prop = segments.properties
+        fields = seg_prop[Labimotion::Prop::LAYERS][field['layer_id']][Labimotion::Prop::FIELDS]
+        fields.find { |ss| ss['field'] == field['field_id'] }&.dig('value')
+      end
 
-    def self.load_from_files
-      merged_data = []
-     # byebug
-      sys_json = File.join(__dir__, 'data', 'vocab', 'System.json')
-    #  byebug
-      file_content = File.read(sys_json)
-      json_data = JSON.parse(file_content)
-      merged_data.concat(json_data)
+      def update_field_value(properties, key, idx, val)
+        properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = val
+      end
 
-      std_json = File.join(__dir__, 'data', 'vocab', 'Standard.json')
-      file_content = File.read(std_json)
-      json_data = JSON.parse(file_content)
-      merged_data.concat(json_data)
-      merged_data
-    end
+      def load_from_files
+        merged_data = []
+        merged_data.concat(load_json_file('System.json'))
+        merged_data.concat(load_json_file('Standard.json'))
+        merged_data
+      end
 
-    def self.load_from_database
-      vocabularies = Labimotion::Vocabulary.all.sort_by(&:name)
-      Labimotion::VocabularyEntity.represent(vocabularies, serializable: true)
-    end
+      def load_json_file(filename)
+        file_path = File.join(__dir__, 'data', 'vocab', filename)
+        file_content = File.read(file_path)
+        JSON.parse(file_content)
+      end
 
-    private_class_method :load_from_files, :load_from_database
+      def load_from_database
+        vocabularies = Labimotion::Vocabulary.all.sort_by(&:name)
+        Labimotion::VocabularyEntity.represent(vocabularies, serializable: true)
+      end
+    end
   end
-end
+end

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

@@ -36,7 +36,7 @@ module Labimotion
           self.con_state = Labimotion::Converter.jcamp_converter(id, current_user)
           update_column(:con_state, con_state)
         when Labimotion::ConState::CONVERTED
-          Labimotion::Converter.metadata(id)
+          Labimotion::Converter.metadata(id, current_user)
         end
       end
     end

data/lib/labimotion/version.rb

@@ -2,5 +2,5 @@
 
 ## Labimotion Version
 module Labimotion
-  VERSION = '1.5.0.rc7'
+  VERSION = '1.5.0.rc8'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 1.5.0.rc7
+  version: 1.5.0.rc8
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-11 00:00:00.000000000 Z
+date: 2024-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -123,7 +123,10 @@ files:
 homepage: https://github.com/LabIMotion/labimotion
 licenses:
 - AGPL-3.0
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/LabIMotion/labimotion
+  source_code_uri: https://github.com/LabIMotion/labimotion
+  bug_tracker_uri: https://github.com/LabIMotion/labimotion/discussions
 post_install_message: 
 rdoc_options: []
 require_paths: