labimotion 1.1.4 → 1.2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75c0801b117991ca8b6dc96daebfedbfdbdc7d40e31bb8c78fbc3f1089eaff91
-  data.tar.gz: 5f67c104d53b3388549064ab3c8e7bebe5df7d39d1075c3d5c42dce5eee9e07e
+  metadata.gz: 7724683d3271fa68ecdf774518cc4d10a4d51ee1431c957e0538c5a00e4f689d
+  data.tar.gz: b9cc8b469761e732707c0b272c2e814a8215c3c22a7d7ca077d7f5ddca9ed877
 SHA512:
-  metadata.gz: a0c036e9a1fc5f3b44130a2e7bf0038f2d0476461ca6a18994564752cf42737486c4d67ec61a0d698af9f28e92bf04c506035954d13b8dbdd2f5a67722c4b694
-  data.tar.gz: 32721efb59f25ed9c2b5ec853987416e2073ab3612881541a9e1e79d2134076998ed18a29cec4efac778f121e6faa3e27d72f0d44e34653e01e9c79e3bebaf95
+  metadata.gz: dd7aaa2347333c05e09eb5e9d0628a8079e2fd4819e46b37e7a45fc40577fae12d2f731a5f1eddd601065c35aa333f312f724bd46b59d93f35f3639f8e34d53b
+  data.tar.gz: f222c51a55a96c1d87c1d79a1fb965b8fb6315a2b182a6767b01222eeae665de248f7bdfdc6ca3789e1f2623faf7a1b69b03bcbc1527f51f6b9c03ba99183d56

data/lib/labimotion/apis/generic_element_api.rb

@@ -287,16 +287,12 @@ module Labimotion
         scope = list_serialized_elements(params, current_user)
 
         reset_pagination_page(scope)
-        if Labimotion::IS_RAILS5 == true
-          generic_elements = paginate(scope).map { |s| ElementListPermissionProxy.new(current_user, s, user_ids).serialized }
-        else
-          generic_elements = paginate(scope).map do |element|
-            Labimotion::ElementEntity.represent(
-              element,
-              displayed_in_list: true,
-              detail_levels: ElementDetailLevelCalculator.new(user: current_user, element: element).detail_levels,
-            )
-          end
+        generic_elements = paginate(scope).map do |element|
+          Labimotion::ElementEntity.represent(
+            element,
+            displayed_in_list: true,
+            detail_levels: ElementDetailLevelCalculator.new(user: current_user, element: element).detail_levels,
+          )
         end
         { generic_elements: generic_elements }
       rescue StandardError => e
@@ -324,7 +320,6 @@ module Labimotion
               attachments: attach_thumbnail(element&.attachments)
             }
           else
-            #byebug
             {
               element: Labimotion::ElementEntity.represent(
                 element,
@@ -352,19 +347,12 @@ module Labimotion
       post do
         begin
           element = create_element(current_user, params)
-          if Labimotion::IS_RAILS5 == true
-            {
-              element: ElementPermissionProxy.new(current_user, element, user_ids).serialized,
-              attachments: attach_thumbnail(element&.attachments)
-            }
-          else
-            present(
-              element,
-              with: Labimotion::ElementEntity,
-              root: :element,
-              detail_levels: ElementDetailLevelCalculator.new(user: current_user, element: element).detail_levels,
-            )
-          end
+          present(
+            element,
+            with: Labimotion::ElementEntity,
+            root: :element,
+            detail_levels: ElementDetailLevelCalculator.new(user: current_user, element: element).detail_levels,
+          )
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)
           raise e
@@ -388,26 +376,32 @@ module Labimotion
         put do
           begin
             element = update_element_by_id(current_user, params)
-            if Labimotion::IS_RAILS5 == true
-              {
-                element: ElementPermissionProxy.new(current_user, element, user_ids).serialized,
-                attachments: attach_thumbnail(element&.attachments)
-              }
-            else
-              {
-                element: Labimotion::ElementEntity.represent(
-                  element,
-                  detail_levels: ElementDetailLevelCalculator.new(user: current_user, element: element).detail_levels,
-                ),
-                attachments: attach_thumbnail(element&.attachments),
-              }
-            end
+            {
+              element: Labimotion::ElementEntity.represent(
+                element,
+                detail_levels: ElementDetailLevelCalculator.new(user: current_user, element: element).detail_levels,
+              ),
+              attachments: attach_thumbnail(element&.attachments),
+            }
           rescue StandardError => e
             Labimotion.log_exception(e, current_user)
             raise e
           end
         end
       end
+
+      namespace :split do
+        desc 'split elements'
+        params do
+          requires :ui_state, type: Hash, desc: 'Selected elements from the UI'
+        end
+        post do
+          split_elements(params[:ui_state], current_user)
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          { error: e.message }
+        end
+      end
     end
   end
 end

data/lib/labimotion/collection/export.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require 'labimotion/utils/export_utils'
 module Labimotion
   ## Export
   class Export
-
     def self.fetch_element_klasses(&fetch_many)
       klasses = Labimotion::ElementKlass.where(is_active: true)
       fetch_many.call(klasses, {'created_by' => 'User'})
+    rescue StandardError => e
+      Labimotion.log_exception(e)
     end
 
     def self.fetch_segment_klasses(&fetch_many)
@@ -15,54 +17,72 @@ module Labimotion
         'element_klass_id' => 'Labimotion::ElementKlass',
         'created_by' => 'User'
         })
+      rescue StandardError => e
+        Labimotion.log_exception(e)
     end
 
     def self.fetch_dataset_klasses(&fetch_many)
       klasses = Labimotion::DatasetKlass.where(is_active: true)
       fetch_many.call(klasses, {'created_by' => 'User'})
+    rescue StandardError => e
+      Labimotion.log_exception(e)
     end
 
-    def self.fetch_elements(collection, segments, attachments, fetch_many, fetch_one, fetch_containers)
-      # fetch_many.call(collection.elements, {
-      #   'element_klass_id' => 'Labimotion::ElementKlass',
-      #   'created_by' => 'User',
-      # })
-      # fetch_many.call(collection.collections_elements, {
-      #         'collection_id' => 'Collection',
-      #         'element_id' => 'Labimotion::Element',
-      # })
+    def self.fetch_elements(collection, uuids, fetch_many, fetch_one, fetch_containers)
+      attachments = []
       collection.elements.each do |element|
-        element, attachments = Labimotion::Export.fetch_properties(data, element, attachments, &fetch_one)
         fetch_one.call(element, {
           'element_klass_id' => 'Labimotion::ElementKlass',
           'created_by' => 'User',
         })
         fetch_containers.call(element)
-        segment, @attachments = Labimotion::Export.fetch_segments(element, attachments, &fetch_one)
-        segments += segment if segment.present?
       end
+      collection.elements.each do |element|
+        element, attachments = Labimotion::ExportUtils.fetch_properties(element, uuids, attachments, &fetch_one)
+        fetch_one.call(element, {
+          'element_klass_id' => 'Labimotion::ElementKlass',
+          'created_by' => 'User',
+        })
+        attachments = Labimotion::Export.fetch_segments(element, uuids, attachments, &fetch_one)
+      end
+      fetch_many.call(collection.collections_elements, {
+        'collection_id' => 'Collection',
+        'element_id' => 'Labimotion::Element',
+      })
 
-      [segments, attachments]
+      attachments
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      attachments
+    end
 
+    def self.fetch_segments_prop(data, uuids)
+      data.fetch(Labimotion::Prop::L_SEGMENT, {}).keys.each do |key|
+        segment = data.fetch(Labimotion::Prop::L_SEGMENT, {})[key]
+        Labimotion::ExportUtils.fetch_seg_properties(segment, uuids)
+        data[Labimotion::Prop::L_SEGMENT][key] = segment
+      end
+      data
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      data
     end
 
-    def self.fetch_segments(element, attachments, &fetch_one)
+    def self.fetch_segments(element, uuids, attachments, &fetch_one)
       element_type = element.class.name
       segments = Labimotion::Segment.where("element_id = ? AND element_type = ?", element.id, element_type)
       segments.each do |segment|
-        # segment = fetch_properties(segment)
-        segment, attachments = Labimotion::Export.fetch_properties(segment, attachments, &fetch_one)
-        # fetch_one.call(segment.segment_klass.element_klass)
-        # fetch_one.call(segment.segment_klass, {
-        #   'element_klass_id' => 'Labimotion::ElementKlass'
-        # })
+        segment, attachments = Labimotion::ExportUtils.fetch_properties(segment, uuids, attachments, &fetch_one)
         fetch_one.call(segment, {
           'element_id' => segment.element_type,
           'segment_klass_id' => 'Labimotion::SegmentKlass',
           'created_by' => 'User'
         })
       end
-      [segments, attachments]
+      attachments
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      attachments
     end
 
     def self.fetch_datasets(dataset, &fetch_one)
@@ -76,68 +96,9 @@ module Labimotion
         'dataset_klass_id' => 'Labimotion::DatasetKlass',
       })
       [dataset]
-    end
-
-
-    def self.fetch_properties(instance, attachments, &fetch_one)
-      properties = instance.properties
-      properties['layers'].keys.each do |key|
-        layer = properties['layers'][key]
-
-        # field_samples = layer['fields'].select { |ss| ss['type'] == 'drag_sample' }  -- TODO for elements
-        # field_elements = layer['fields'].select { |ss| ss['type'] == 'drag_element' }  -- TODO for elements
-
-        field_molecules = layer['fields'].select { |ss| ss['type'] == 'drag_molecule' }
-        field_molecules.each do |field|
-          idx = properties['layers'][key]['fields'].index(field)
-          id = field["value"] && field["value"]["el_id"] unless idx.nil?
-          mol = Molecule.find(id) unless id.nil?
-          properties['layers'][key]['fields'][idx]['value']['el_id'] = fetch_one.call(mol) unless mol.nil?
-        end
-
-        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?
-          # ss = Sample.find(id) unless id.nil?
-          # properties['layers'][key]['fields'][idx]['value']['el_id'] = fetch_one.call(ss) unless ss.nil?
-        end
-
-        field_uploads = layer['fields'].select { |ss| ss['type'] == 'upload' }
-        field_uploads.each do |upload|
-          idx = properties['layers'][key]['fields'].index(upload)
-          files = upload["value"] && upload["value"]["files"]
-          files&.each_with_index do |fi, fdx|
-            att = Attachment.find(fi['aid'])
-            attachments += [att]
-            properties['layers'][key]['fields'][idx]['value']['files'][fdx]['aid'] = fetch_one.call(att, {'attachable_id' => 'Labimotion::Segment'}) unless att.nil?
-          end
-        end
-
-        field_tables = properties['layers'][key]['fields'].select { |ss| ss['type'] == 'table' }
-        field_tables&.each do |field|
-          next unless field['sub_values'].present? && field['sub_fields'].present?
-          # field_table_samples = field['sub_fields'].select { |ss| ss['type'] == 'drag_sample' }  -- not available yet
-          # field_table_uploads = field['sub_fields'].select { |ss| ss['type'] == 'upload' }       -- not available yet
-          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 do |sub_value|
-                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_by(id: svalue['el_id'])
-                sub_value[col_id]['value']['el_id'] = fetch_one.call(tmol) unless tmol.nil?
-              end
-            end
-          end
-        end
-      end
-      instance.properties = properties
-      [instance, attachments]
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      [dataset]
     end
   end
 end

data/lib/labimotion/collection/import.rb

@@ -3,14 +3,13 @@
 require 'labimotion/utils/import_utils'
 module Labimotion
   class Import
-
     def self.import_repo_segment_props(instances, attachments, attachable_uuid, fields)
       primary_store = Rails.configuration.storage.primary_store
       attachable = instances.fetch('Labimotion::Segment').fetch(attachable_uuid)
       attachment = Attachment.where(id: attachments, filename: fields.fetch('identifier')).first
       attachment.update!(
         attachable_id: attachable.id,
-        attachable_type: 'SegmentProps',
+        attachable_type: Labimotion::Prop::SEGMENTPROPS,
         con_state: Labimotion::ConState::NONE,
         transferred: true,
         aasm_state: fields.fetch('aasm_state'),
@@ -23,22 +22,25 @@ module Labimotion
       )
 
       properties = attachable.properties
-      properties['layers'].keys.each do |key|
-        layer = properties['layers'][key]
-        field_uploads = layer['fields'].select { |ss| ss['type'] == 'upload' }
+      properties[Labimotion::Prop::LAYERS].keys.each do |key|
+        layer = properties[Labimotion::Prop::LAYERS][key]
+        field_uploads = layer[Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::UPLOAD }
         field_uploads&.each do |upload|
-          idx = properties['layers'][key]['fields'].index(upload)
+          idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(upload)
           files = upload["value"] && upload["value"]["files"]
           files&.each_with_index do |fi, fdx|
-            if properties['layers'][key]['fields'][idx]['value']['files'][fdx]['uid'] == fields.fetch('identifier')
-              properties['layers'][key]['fields'][idx]['value']['files'][fdx]['aid'] = attachment.id
-              properties['layers'][key]['fields'][idx]['value']['files'][fdx]['uid'] = attachment.identifier
+            if properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['files'][fdx]['uid'] == fields.fetch('identifier')
+              properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['files'][fdx]['aid'] = attachment.id
+              properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['files'][fdx]['uid'] = attachment.identifier
             end
           end
         end
       end
       attachable.update!(properties: properties)
       attachment
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      attachment
     end
 
     def self.import_datasets(data, instances, gt, current_user_id, &update_instances)
@@ -75,59 +77,59 @@ module Labimotion
           update_instances.call(uuid, dataset)
         end
       rescue StandardError => e
-        Rails.logger.error(e.backtrace)
+        Labimotion.log_exception(e)
         raise
       end
     end
 
-    def self.import_segments(data, instances, gt, current_user_id, &update_instances)
-      begin
-        data.fetch('Labimotion::Segment', {}).each do |uuid, fields|
-          klass_id = fields["segment_klass_id"]
-          sk_obj = data.fetch('Labimotion::SegmentKlass', {})[klass_id]
-          sk_id = sk_obj["identifier"]
-          ek_obj = data.fetch('Labimotion::ElementKlass').fetch(sk_obj["element_klass_id"])
-          element_klass = Labimotion::ElementKlass.find_by(name: ek_obj['name']) if ek_obj.present?
-          next if element_klass.nil? || ek_obj.nil? || ek_obj['is_generic'] == true
-
-          element_uuid = fields.fetch('element_id')
-          element_type = fields.fetch('element_type')
-          element = instances.fetch(element_type).fetch(element_uuid)
-          segment_klass = Labimotion::SegmentKlass.find_by(identifier: sk_id) if sk_id.present?
-          segment_klass = Labimotion::SegmentKlass.find_by(uuid: fields.fetch('klass_uuid')) if segment_klass.nil?
-
-          if segment_klass.nil?
-            skr = Labimotion::SegmentKlassesRevision.find_by(uuid: fields.fetch('klass_uuid'))
-            segment_klass = skr.segment_klass if segment_klass.nil? && skr.present?
-          end
+    def self.import_segments(data, instances, attachments, gt, current_user_id, &update_instances)
+      data.fetch(Labimotion::Prop::L_SEGMENT, {}).each do |uuid, fields|
+        klass_id = fields["segment_klass_id"]
+        sk_obj = data.fetch(Labimotion::Prop::L_SEGMENT_KLASS, {})[klass_id]
+        sk_id = sk_obj["identifier"]
+        ek_obj = data.fetch(Labimotion::Prop::L_ELEMENT_KLASS).fetch(sk_obj["element_klass_id"])
+        element_klass = Labimotion::ElementKlass.find_by(name: ek_obj['name']) if ek_obj.present?
+        next if element_klass.nil? || ek_obj.nil? || ek_obj['is_generic'] == true
+
+        element_uuid = fields.fetch('element_id')
+        element_type = fields.fetch('element_type')
+        element = instances.fetch(element_type).fetch(element_uuid)
+        segment_klass = Labimotion::SegmentKlass.find_by(identifier: sk_id) if sk_id.present?
+        segment_klass = Labimotion::SegmentKlass.find_by(uuid: fields.fetch('klass_uuid')) if segment_klass.nil?
+
+        if segment_klass.nil?
+          skr = Labimotion::SegmentKlassesRevision.find_by(uuid: fields.fetch('klass_uuid'))
+          segment_klass = skr.segment_klass if segment_klass.nil? && skr.present?
+        end
 
-          next if segment_klass.nil? || element.nil?
+        next if segment_klass.nil? || element.nil?
 
-          ## segment_klass = Labimotion::ImportUtils.create_segment_klass(sk_obj, segment_klass, element_klass, current_user_id)
+        ## segment_klass = Labimotion::ImportUtils.create_segment_klass(sk_obj, segment_klass, element_klass, current_user_id)
 
-          segment = Labimotion::Segment.create!(
-            fields.slice(
-              'properties', 'properties_release'
-            ).merge(
-              created_by: current_user_id,
-              element: element,
-              segment_klass: segment_klass,
-              uuid: SecureRandom.uuid,
-              klass_uuid: skr&.uuid || segment_klass.uuid
-            )
+        segment = Labimotion::Segment.create!(
+          fields.slice(
+            'properties', 'properties_release'
+          ).merge(
+            created_by: current_user_id,
+            element: element,
+            segment_klass: segment_klass,
+            uuid: SecureRandom.uuid,
+            klass_uuid: skr&.uuid || segment_klass.uuid
           )
-
-          properties = Labimotion::ImportUtils.properties_handler(data, segment.properties)
-          segment.update!(properties: properties)
-          update_instances.call(uuid, segment)
-        end
-      rescue StandardError => e
-        Rails.logger.error(e.backtrace)
-        raise
+        )
+        properties = Labimotion::ImportUtils.properties_handler(data, instances, attachments, segment, nil)
+        segment.update!(properties: properties)
+        update_instances.call(uuid, segment)
       end
+
+      Labimotion::ImportUtils.process_ai(data, instances)
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      raise
     end
 
-    def self.import_elements(data, instances, gt, current_user_id, fetch_many, &update_instances)
+    def self.import_elements(data, instances, attachments, gt, current_user_id, fetch_many, &update_instances)
+      elements = {}
       data.fetch('Labimotion::Element', {}).each do |uuid, fields|
         klass_id = fields["element_klass_id"]
         ek_obj = data.fetch('Labimotion::ElementKlass', {})[klass_id]
@@ -154,14 +156,18 @@ module Labimotion
             klass_uuid: ekr&.uuid || element_klass.uuid
           )
         )
-
-        properties = Labimotion::ImportUtils.properties_handler(data, element.properties)
+        elements[uuid] = element
+      end
+      elements.keys.each do |uuid, element|
+        element = elements[uuid]
+        properties = Labimotion::ImportUtils.properties_handler(data, instances, attachments, element, elements)
         element.update!(properties: properties)
         update_instances.call(uuid, element)
         element.container = Container.create_root_container
+        element.save!
       end
     rescue StandardError => e
-      Rails.logger.error(e.backtrace)
+      Labimotion.log_exception(e)
       raise
     end
   end

data/lib/labimotion/entities/element_revision_entity.rb

@@ -10,27 +10,27 @@ module Labimotion
     end
 
     def properties
-      object.properties['layers']&.keys.each do |key|
-        field_sample_molecules = object.properties['layers'][key]['fields'].select { |ss| ss['type'] == 'drag_sample' || ss['type'] == 'drag_molecule' }
+      object.properties[Labimotion::Prop::LAYERS]&.keys.each do |key|
+        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['layers'][key]['fields'].index(field)
+          idx = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
           sid = field.dig('value', 'el_id')
           next unless sid.present?
 
-          el = field['type'] == 'drag_sample' ? Sample.find_by(id: sid) : Molecule.find_by(id: sid)
+          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('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 field['type'] == 'drag_sample'
-          object.properties['layers'][key]['fields'][idx]['value']['el_tip'] = el.short_label if field['type'] == 'drag_sample'
-          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)
+          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)
         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|
           next unless field['sub_values'].present? && field['sub_fields'].present?
 
-          field_table_molecules = field['sub_fields'].select { |ss| ss['type'] == 'drag_molecule' }
+          field_table_molecules = field['sub_fields'].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_MOLECULE }
           next unless field_table_molecules.present?
 
           col_ids = field_table_molecules.map { |x| x.values[0] }

data/lib/labimotion/entities/eln_element_entity.rb

@@ -24,47 +24,47 @@ module Labimotion
     private
 
     def properties
-      (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 do |ss|
-          ss['type'] == 'drag_sample' || ss['type'] == 'drag_molecule'
+        field_sample_molecules = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].select do |ss|
+          ss['type'] == Labimotion::FieldType::DRAG_SAMPLE || ss['type'] == Labimotion::FieldType::DRAG_MOLECULE
         end
         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', 'el_id')
           next unless sid.present?
 
-          el = field['type'] == 'drag_sample' ? Sample.find_by(id: sid) : Molecule.find_by(id: sid)
+          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('layers', key, 'fields', idx, 'value').present?
+          next unless object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value').present?
 
-          if field['type'] == 'drag_sample'
-            object.properties['layers'][key]['fields'][idx]['value']['el_label'] =
+          if field['type'] == Labimotion::FieldType::DRAG_SAMPLE
+            object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_label'] =
               el.short_label
           end
-          if field['type'] == 'drag_sample'
-            object.properties['layers'][key]['fields'][idx]['value']['el_tip'] =
+          if field['type'] == Labimotion::FieldType::DRAG_SAMPLE
+            object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_tip'] =
               el.short_label
           end
-          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)
+          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)
         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' }
+          field_table_molecules = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_MOLECULE }
           if field_table_molecules.present?
-            object.properties['layers'][key]['fields'][idx] =
-              set_table(field, field_table_molecules, 'Molecule')
+            object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] =
+              set_table(field, field_table_molecules, Labimotion::Prop::MOLECULE)
           end
 
-          field_table_samples = field['sub_fields'].select { |ss| ss['type'] == 'drag_sample' }
+          field_table_samples = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_SAMPLE }
           if field_table_samples.present?
-            object.properties['layers'][key]['fields'][idx] =
-              set_table(field, field_table_samples, 'Sample')
+            object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] =
+              set_table(field, field_table_samples, Labimotion::Prop::SAMPLE)
           end
         end
       end
@@ -87,13 +87,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