labimotion 1.1.4 → 1.2.0.0

data/lib/labimotion/utils/import_utils.rb

@@ -1,92 +1,277 @@
 # frozen_string_literal: true
 
 module Labimotion
-  ## Import Utils
   class ImportUtils
-    def self.proc_sample(layer, key, data, properties)
-      field_samples = layer['fields'].select { |ss| ss['type'] == 'drag_sample' }
-      field_samples.each do |field|
-        idx = properties['layers'][key]['fields'].index(field)
-        id = field["value"] && field["value"]["el_id"] unless idx.nil?
+    class << self
+      private
+      def upload_type(element)
+        return nil if element.nil?
+
+        case Labimotion::Utils.element_name(element.class.name)
+        when Labimotion::Prop::ELEMENT
+          Labimotion::Prop::ELEMENTPROPS
+        when Labimotion::Prop::SEGMENT
+          Labimotion::Prop::SEGMENTPROPS
+        when Labimotion::Prop::DATASET
+          Labimotion::Prop::DATASETPROPS
+        end
+      end
+
+      def proc_assign_molecule(value, molecule)
+        return {} if molecule.nil?
+
+        value = {} if value.nil? || value.is_a?(String)
+        value['el_id'] = molecule.id
+        value['el_tip'] = "#{molecule.inchikey}@@#{molecule.cano_smiles}"
+        value['el_label'] = molecule.iupac_name
+        value['el_svg'] = File.join('/images', 'molecules', molecule.molecule_svg_file)
+        value['el_inchikey'] = molecule.inchikey
+        value['el_smiles'] = molecule.cano_smiles
+        value['el_type'] = 'molecule' if value['el_type'].nil?
+        value['el_iupac'] = molecule.iupac_name
+        value['el_molecular_weight'] = molecule.molecular_weight
+        value
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        value
+      end
+
+      def proc_assign_sample(value, sample)
+        return {} if sample.nil?
+
+        value = {} if value.nil? || value.is_a?(String)
+        value['el_id'] = sample.id
+        value['el_type'] = 'sample' if value['el_type'].nil?
+        value['el_tip'] = sample.short_label
+        value['el_label'] = sample.short_label
+        value['el_svg'] = sample.get_svg_path
+        value
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        value
+      end
+
+      def proc_assign_element(value, element)
+        return {} if element.nil?
+
+        value = {} if value.nil? || value.is_a?(String)
+        value['el_id'] = element.id
+        value['el_type'] = 'element' if value['el_type'].nil?
+        value['el_tip'] = element.short_label
+        value['el_label'] = element.short_label
+        value
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        value
+      end
+
+      def proc_assign_upload(value, attachment)
+        return {} if attachment.nil?
+
+        value = {} if value.nil? || value.is_a?(String)
+        value['aid'] = attachment.id
+        value['uid'] = attachment.identifier
+        value['filename'] = attachment.filename
+        value
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        value
+      end
+
+
+      def proc_table_molecule(properties, data, svalue, key, tidx, vdx, col_id)
+        return properties unless id = svalue.fetch('el_id', nil)
+
+        molfile = data.fetch(Labimotion::Prop::MOLECULE, nil)&.fetch(id, nil)&.fetch('molfile', nil)
+        tmol = Molecule.find_or_create_by_molfile(molfile) if molfile.present?
+        val = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][tidx]['sub_values'][vdx][col_id]['value']
+        properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][tidx]['sub_values'][vdx][col_id]['value'] = proc_assign_molecule(val, tmol)
+        properties
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        properties
+      end
+
+      def proc_table_sample(properties, data, instances, svalue, key, tidx, vdx, col_id)
+        return properties unless id = svalue.fetch('el_id', nil)
+
+        # orig_s = data.fetch(Labimotion::Prop::SAMPLE, nil)&.fetch(svalue['el_id'], nil)
+        sample = instances.fetch(Labimotion::Prop::SAMPLE, nil)&.fetch(id, nil)
+        val = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][tidx]['sub_values'][vdx][col_id]['value']
+        properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][tidx]['sub_values'][vdx][col_id]['value'] = proc_assign_sample(val, sample)
+        properties
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        properties
+      end
+
+      def proc_table_prop(layer, key, data, instance, properties, field, tidx, type)
+        fields = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == type }
+        return properties if fields.nil?
+
+        col_ids = fields.map { |x| x.values[0] }
+        col_ids.each do |col_id|
+          next if field[Labimotion::Prop::SUBVALUES].nil?
+
+          field[Labimotion::Prop::SUBVALUES].each_with_index do |sub_value, vdx|
+            next unless sub_value.fetch(col_id, nil)&.fetch('value', nil).is_a?(Hash)
+
+            next if sub_value.fetch(col_id, nil)&.fetch('value', nil)&.fetch('el_id', nil).nil?
+
+            svalue = sub_value.fetch(col_id, nil)&.fetch('value', nil)
+            next if svalue.fetch('el_id', nil).nil? ## || svalue.fetch('el_inchikey', nil).nil? (molecule only?)
+
+            case type
+            when Labimotion::FieldType::DRAG_MOLECULE
+              properties = proc_table_molecule(properties, data, svalue, key, tidx, vdx, col_id)
+            when Labimotion::FieldType::DRAG_SAMPLE
+              properties = proc_table_sample(properties, data, instance, svalue, key, tidx, vdx, col_id)
+            end
+          end
+        end
+        properties
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        properties
+      end
+    end
 
-        # mol = Molecule.find_or_create_by_molfile(data.fetch('Molecule')[id]['molfile']) unless id.nil?
-        # unless mol.nil?
-        #   properties['layers'][key]['fields'][idx]['value']['el_id'] = mol.id
-        #   properties['layers'][key]['fields'][idx]['value']['el_tip'] = "#{mol.inchikey}@@#{mol.cano_smiles}"
-        #   properties['layers'][key]['fields'][idx]['value']['el_label'] = mol.iupac_name
-        # end
+    def self.proc_sample(layer, key, data, instances, properties)
+      fields = layer[Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_SAMPLE }
+      fields.each do |field|
+        idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
+        id = field["value"] && field["value"]["el_id"] unless idx.nil?
+        sample = instances.fetch(Labimotion::Prop::SAMPLE, nil)&.fetch(id, nil)
+        val = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']
+        val = proc_assign_sample(val, sample)
+        properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = val
       end
       properties
     rescue StandardError => e
-      Rails.logger.error(e.backtrace)
+      Labimotion.log_exception(e)
       raise
     end
 
-    def self.proc_molecule(layer, key, data, properties)
-      field_molecules = layer['fields'].select { |ss| ss['type'] == 'drag_molecule' }
-      field_molecules.each do |field|
-        idx = properties['layers'][key]['fields'].index(field)
+    def self.proc_element(layer, key, data, instances, properties, elements)
+      fields = layer[Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_ELEMENT }
+      fields.each do |field|
+        idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
         id = field["value"] && field["value"]["el_id"] unless idx.nil?
-        mol = Molecule.find_or_create_by_molfile(data.fetch('Molecule')[id]['molfile']) unless id.nil?
-        unless mol.nil?
-          properties['layers'][key]['fields'][idx]['value']['el_id'] = mol.id
-          properties['layers'][key]['fields'][idx]['value']['el_tip'] = "#{mol.inchikey}@@#{mol.cano_smiles}"
-          properties['layers'][key]['fields'][idx]['value']['el_label'] = mol.iupac_name
+        att_el = (elements && elements[id]) || instances.fetch(Labimotion::Prop::L_ELEMENT, nil)&.fetch(id, nil)
+        if att_el.nil?
+          properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = {}
+        else
+          val = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']
+          val = proc_assign_element(val, att_el)
+          properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = val
         end
       end
       properties
     rescue StandardError => e
-      Rails.logger.error(e.backtrace)
+      Labimotion.log_exception(e)
       raise
     end
 
-    def self.proc_table(layer, key, data, properties)
-      field_tables = layer['fields'].select { |ss| ss['type'] == 'table' }
-      field_tables&.each do |field|
-        tidx = layer['fields'].index(field)
-        next unless field['sub_values'].present? && field['sub_fields'].present?
-
-        field_table_molecules = field['sub_fields'].select { |ss| ss['type'] == 'drag_molecule' }
-        if field_table_molecules.present?
-          col_ids = field_table_molecules.map { |x| x.values[0] }
-          col_ids.each do |col_id|
-            field['sub_values'].each_with_index do |sub_value, vdx|
-              next unless sub_value[col_id].present? && sub_value[col_id]['value'].present? && sub_value[col_id]['value']['el_id'].present?
-
-              svalue = sub_value[col_id]['value']
-              next unless svalue['el_id'].present? && svalue['el_inchikey'].present?
-
-              tmol = Molecule.find_or_create_by_molfile(data.fetch('Molecule')[svalue['el_id']]['molfile']) unless svalue['el_id'].nil?
-              unless tmol.nil?
-                properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_id'] = tmol.id
-                properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_tip'] = "#{tmol.inchikey}@@#{tmol.cano_smiles}"
-                properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_label'] = tmol.cano_smiles
-                properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_smiles'] = tmol.cano_smiles
-                properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_iupac'] = tmol.iupac_name
-                properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_inchikey'] = tmol.inchikey
-                properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_svg'] = File.join('/images', 'molecules', tmol.molecule_svg_file)
-                properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_molecular_weight'] = tmol.molecular_weight
-              end
-            end
-          end
+    def self.proc_upload(layer, key, data, instances, attachments, element)
+      properties = element.properties
+      upload_type = upload_type(element)
+      return if upload_type.nil?
+
+      fields = layer[Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::UPLOAD }
+      fields.each do |field|
+        idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
+        next if idx.nil?
+
+        files = field["value"] && field["value"]["files"]
+        files&.each_with_index do |fi, fdx|
+          aid = properties['layers'][key]['fields'][idx]['value']['files'][fdx]['aid']
+          uid = properties['layers'][key]['fields'][idx]['value']['files'][fdx]['uid']
+          att = data.fetch('Attachment', nil)&.fetch(aid, nil)
+          attachment = Attachment.find_by('id IN (?) AND filename LIKE ? ', attachments, uid << '%')
+          next if attachment.nil? || att.nil?
+
+          attachment.update!(attachable_id: element.id, attachable_type: upload_type, transferred: true, aasm_state: att['aasm_state'], filename: att['filename'])
+          val = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['files'][fdx]
+          val = proc_assign_upload(val, attachment)
+          properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['files'][fdx] = val
         end
       end
       properties
     rescue StandardError => e
-      Rails.logger.error(e.backtrace)
+      Labimotion.log_exception(e)
+      properties
+    end
+
+    def self.proc_molecule(layer, key, data, properties)
+      fields = layer[Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_MOLECULE }
+      fields.each do |field|
+        idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
+        next if idx.nil? || field.fetch('value', nil).nil?
+
+        next unless field.fetch('value', nil).is_a?(Hash)
+
+        id = field.fetch('value', nil)&.fetch('el_id', nil) unless idx.nil?
+        molfile = data.fetch(Labimotion::Prop::MOLECULE, nil)&.fetch(id, nil)&.fetch('molfile', nil) unless id.nil?
+        next if molfile.nil?
+
+        mol = Molecule.find_or_create_by_molfile(molfile)
+        val = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']
+        properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = proc_assign_molecule(val, mol)
+      end
+      properties
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      raise
+    end
+
+
+    def self.proc_table(layer, key, data, instance, properties)
+      fields = layer[Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::TABLE }
+      fields&.each do |field|
+        tidx = layer[Labimotion::Prop::FIELDS].index(field)
+        next unless field['sub_values'].present? && field[Labimotion::Prop::SUBFIELDS].present?
+
+        proc_table_prop(layer, key, data, instance, properties, field, tidx, Labimotion::FieldType::DRAG_MOLECULE)
+        proc_table_prop(layer, key, data, instance, properties, field, tidx, Labimotion::FieldType::DRAG_SAMPLE)
+      end
+      properties
+    rescue StandardError => e
+      Labimotion.log_exception(e)
       raise
     end
 
-    def self.properties_handler(data, properties)
-      properties && properties['layers'] && properties['layers'].keys&.each do |key|
-        layer = properties['layers'][key]
+    def self.properties_handler(data, instances, attachments, elmenet, elements)
+      properties = elmenet.properties
+      properties.fetch(Labimotion::Prop::LAYERS, nil)&.keys&.each do |key|
+        layer = properties[Labimotion::Prop::LAYERS][key]
         properties = proc_molecule(layer, key, data, properties)
-        properties = proc_table(layer, key, data, properties)
-        # properties = proc_sample(layer, key, data, properties)
+        properties = proc_upload(layer, key, data, instances, attachments, elmenet)
+        properties = proc_sample(layer, key, data, instances, properties)
+        properties = proc_element(layer, key, data, instances, properties, elements) # unless elements.nil?
+        properties = proc_table(layer, key, data, instances, properties)
       end
       properties
     rescue StandardError => e
-      Rails.logger.error(e.backtrace)
+      Labimotion.log_exception(e)
+      raise
+    end
+
+    def self.process_ai(data, instances)
+      ai_has_changed = false
+      instances&.fetch(Labimotion::Prop::L_ELEMENT, nil)&.each do |uuid, element|
+        properties = element.properties
+        properties.fetch(Labimotion::Prop::LAYERS, nil)&.keys&.each do |key|
+          layer = properties[Labimotion::Prop::LAYERS][key]
+          layer.fetch('ai', nil)&.each_with_index do |ai_key, idx|
+            ana = instances.fetch(Labimotion::Prop::CONTAINER)&.fetch(ai_key, nil)
+            properties[Labimotion::Prop::LAYERS][key]['ai'][idx] = ana.id unless ana.nil?
+            ai_has_changed = true
+          end
+        end
+        element.update_columns(properties: properties) if ai_has_changed
+      end
+    rescue StandardError => e
+      Labimotion.log_exception(e)
       raise
     end
 

data/lib/labimotion/utils/prop.rb

@@ -0,0 +1,27 @@
+module Labimotion
+  ## Converter State
+  class Prop
+    LAYERS = 'layers'.freeze
+    FIELDS = 'fields'.freeze
+    SUBFIELDS = 'sub_fields'.freeze
+    SUBVALUES = 'sub_values'.freeze
+    SEL_OPTIONS = 'select_options'.freeze
+    L_DATASET_KLASS = 'Labimotion::DatasetKlass'.freeze
+    L_ELEMENT_KLASS = 'Labimotion::ElementKlass'.freeze
+    L_SEGMENT_KLASS = 'Labimotion::SegmentKlass'.freeze
+    L_ELEMENT = 'Labimotion::Element'.freeze
+    L_SEGMENT = 'Labimotion::Segment'.freeze
+    L_DATASET = 'Labimotion::Dataset'.freeze
+    SEGMENT = 'Segment'.freeze
+    ELEMENT = 'Element'.freeze
+    DATASET = 'Dataset'.freeze
+    SAMPLE = 'Sample'.freeze
+    MOLECULE = 'Molecule'.freeze
+    REACTION = 'Reaction'.freeze
+    CONTAINER = 'Container'.freeze
+    ELEMENTPROPS = 'ElementProps'.freeze
+    SEGMENTPROPS = 'SegmentProps'.freeze
+    DATASETPROPS = 'DatasetProps'.freeze
+    UPLOADPROPS = [ELEMENTPROPS, SEGMENTPROPS, DATASETPROPS].freeze
+  end
+end

data/lib/labimotion/utils/search.rb

@@ -30,7 +30,7 @@ module Labimotion
               query_field = { "fields": [{ "field": f[:field].to_s, "sub_fields": sfs }] } unless sfs.empty?
             elsif %w[checkbox integer system-defined].include? f[:type]
               query_field = { "fields": [{ "field": f[:field].to_s, "value": f[:value] }] }
-            elsif %w[drag_element drag_molecule drag_sample].include? f[:type]
+            elsif Labimotion::FieldType::DRAG_ALL.include? f[:type]
               vfs = { "el_label": f[:value] }
               query_field = { "fields": [{ "field": f[:field].to_s, "value": vfs }] } unless f[:value].empty?
             else
@@ -70,7 +70,7 @@ module Labimotion
                 query_field = { "fields": [{ "field": f[:field].to_s, "sub_fields": sfs }] } unless sfs.empty?
               elsif %w[checkbox integer system-defined].include? f[:type]
                 query_field = { "fields": [{ "field": f[:field].to_s, "value": f[:value] }] }
-              elsif %w[drag_element drag_molecule drag_sample].include? f[:type]
+              elsif Labimotion::FieldType::DRAG_ALL.include? f[:type]
                 vfs = { "el_label": f[:value] }
                 query_field = { "fields": [{ "field": f[:field].to_s, "value": vfs }] } unless f[:value].empty?
               else

data/lib/labimotion/utils/serializer.rb

@@ -12,13 +12,13 @@ module Labimotion
           next unless find_obj.present?
 
           case obj
-          when 'Molecule'
+          when Labimotion::Prop::MOLECULE
             sub_value[col_id]['value']['el_svg'] = File.join('/images', 'molecules', find_obj.molecule_svg_file)
             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
-          when 'Sample'
+          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
@@ -33,43 +33,43 @@ module Labimotion
     end
 
     def self.element_properties(object)
-      object.properties['layers']&.keys.each do |key|
+      object.properties[Labimotion::Prop::LAYERS]&.keys.each do |key|
         # layer = object.properties[key]
-        field_sample_molecules = object.properties['layers'][key]['fields'].select { |ss| %w[drag_sample drag_element drag_element].include?(ss['type']) }
+        field_sample_molecules = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].select { |ss| Labimotion::FieldType::DRAG_ALL.include?(ss['type']) }
         field_sample_molecules.each do |field|
-          idx = object.properties['layers'][key]['fields'].index(field)
+          idx = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
           sid = field.dig('value') != '' && field.dig('value', 'el_id')
           next unless sid.present?
 
           case field['type']
-          when 'drag_sample'
+          when Labimotion::FieldType::DRAG_SAMPLE
             el = Sample.find_by(id: sid)
-          when 'drag_molecule'
+          when Labimotion::FieldType::DRAG_MOLECULE
             el = Molecule.find_by(id: sid)
-          when 'drag_element'
+          when Labimotion::FieldType::DRAG_ELEMENT
             el = Labimotion::Element.find_by(id: sid)
           end
           next unless el.present?
-          next unless object.properties.dig('layers', key, 'fields', idx, 'value').present?
+          next unless object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value').present?
 
-          object.properties['layers'][key]['fields'][idx]['value']['el_label'] = el.short_label if %w[drag_sample drag_element].include?(field['type'])
-          object.properties['layers'][key]['fields'][idx]['value']['el_tip'] = el.short_label if %w[drag_sample].include?(field['type'])
-          object.properties['layers'][key]['fields'][idx]['value']['el_tip'] = "#{el.element_klass&.label}@@#{el.name}" if %w[drag_element].include?(field['type'])
-          object.properties['layers'][key]['fields'][idx]['value']['icon_name'] = el.element_klass&.icon_name || '' if %w[drag_element].include?(field['type'])
-          object.properties['layers'][key]['fields'][idx]['value']['el_svg'] = field['type'] == 'drag_sample' ? el.get_svg_path : File.join('/images', 'molecules', el.molecule_svg_file) if %w[drag_sample drag_molecule].include?(field['type'])
-          object.properties['layers'][key]['fields'][idx]['value']['el_decoupled'] = el.decoupled if %w[drag_sample].include?(field['type'])
+          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_label'] = el.short_label if %w[drag_sample drag_element].include?(field['type'])
+          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_tip'] = el.short_label if %w[drag_sample].include?(field['type'])
+          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_tip'] = "#{el.element_klass&.label}@@#{el.name}" if %w[drag_element].include?(field['type'])
+          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['icon_name'] = el.element_klass&.icon_name || '' if %w[drag_element].include?(field['type'])
+          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) if Labimotion::FieldType::DRAG_MS.include?(field['type'])
+          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_decoupled'] = el.decoupled if %w[drag_sample].include?(field['type'])
         end
 
-        field_tables = object.properties['layers'][key]['fields'].select { |ss| ss['type'] == 'table' }
+        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['layers'][key]['fields'].index(field)
-          next unless field['sub_values'].present? && field['sub_fields'].present?
+          idx = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
+          next unless field['sub_values'].present? && field[Labimotion::Prop::SUBFIELDS].present?
 
-          field_table_molecules = field['sub_fields'].select { |ss| ss['type'] == 'drag_molecule' }
-          object.properties['layers'][key]['fields'][idx] = set_table(field, field_table_molecules, 'Molecule') if field_table_molecules.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['sub_fields'].select { |ss| ss['type'] == 'drag_sample' }
-          object.properties['layers'][key]['fields'][idx] = set_table(field, field_table_samples, 'Sample') if field_table_samples.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
       end
       object.properties

data/lib/labimotion/version.rb

@@ -3,5 +3,5 @@
 ## Labimotion Version
 module Labimotion
   IS_RAILS5 = false
-  VERSION = '1.1.4'
+  VERSION = '1.2.0.0'
 end

data/lib/labimotion.rb

@@ -59,13 +59,15 @@ module Labimotion
   autoload :TemplateHub, 'labimotion/libs/template_hub'
   autoload :ExportDataset, 'labimotion/libs/export_dataset'
   autoload :SampleAssociation, 'labimotion/libs/sample_association'
+  autoload :PropertiesHandler, 'labimotion/libs/properties_handler'
 
   ######## Utils
+  autoload :Prop, 'labimotion/utils/prop'
   autoload :ConState, 'labimotion/utils/con_state'
+  autoload :FieldType, 'labimotion/utils/field_type'
   autoload :Serializer, 'labimotion/utils/serializer'
   autoload :Search, 'labimotion/utils/search'
 
-
   ######## Collection
   autoload :Export, 'labimotion/collection/export'
   autoload :Import, 'labimotion/collection/import'
@@ -97,6 +99,7 @@ module Labimotion
   autoload :Segmentable, 'labimotion/models/concerns/segmentable'
   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: 1.1.4
+  version: 1.2.0.0
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-15 00:00:00.000000000 Z
+date: 2024-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -67,6 +67,7 @@ files:
 - lib/labimotion/libs/converter.rb
 - lib/labimotion/libs/export_dataset.rb
 - lib/labimotion/libs/nmr_mapper.rb
+- lib/labimotion/libs/properties_handler.rb
 - lib/labimotion/libs/sample_association.rb
 - lib/labimotion/libs/template_hub.rb
 - lib/labimotion/models/collections_element.rb
@@ -74,6 +75,7 @@ files:
 - lib/labimotion/models/concerns/datasetable.rb
 - lib/labimotion/models/concerns/generic_klass_revisions.rb
 - lib/labimotion/models/concerns/generic_revisions.rb
+- lib/labimotion/models/concerns/linked_properties.rb
 - lib/labimotion/models/concerns/segmentable.rb
 - lib/labimotion/models/concerns/workflow.rb
 - lib/labimotion/models/dataset.rb
@@ -92,7 +94,10 @@ files:
 - lib/labimotion/models/segment_klasses_revision.rb
 - lib/labimotion/models/segments_revision.rb
 - lib/labimotion/utils/con_state.rb
+- lib/labimotion/utils/export_utils.rb
+- lib/labimotion/utils/field_type.rb
 - lib/labimotion/utils/import_utils.rb
+- lib/labimotion/utils/prop.rb
 - lib/labimotion/utils/search.rb
 - lib/labimotion/utils/serializer.rb
 - lib/labimotion/utils/utils.rb