labimotion 1.1.4 → 1.2.0.1

data/lib/labimotion/libs/properties_handler.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class PropertiesHandler
+    class << self
+      private
+
+      def check_val(field, type)
+        case type
+        when Labimotion::FieldType::DRAG_SAMPLE, Labimotion::FieldType::DRAG_ELEMENT
+          return field.dig('value', 'el_id').present?
+        when Labimotion::FieldType::UPLOAD
+          return field.dig('value', 'files')&.length&.positive?
+        when Labimotion::FieldType::TABLE
+          return field[Labimotion::Prop::SUBFIELDS]&.length&.positive? && field['sub_values']&.length&.positive?
+        end
+        false
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        false
+      end
+
+      def detach_val(properties, field, key, type)
+        case type
+        when Labimotion::FieldType::DRAG_SAMPLE, Labimotion::FieldType::DRAG_ELEMENT, Labimotion::FieldType::UPLOAD
+          idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
+          properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = {}
+        when Labimotion::FieldType::TABLE
+          return properties if check_table_val(field)
+
+          idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
+          properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['sub_values'] = []
+        end
+        properties
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        properties
+      end
+
+      def check_table_val(field)
+        tsf_samples = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_SAMPLE }
+        tsf_elements = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_ELEMENT }
+        tsf_samples.length.zero? && tsf_elements.length.zero?
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        false
+      end
+    end
+
+    def self.check_properties(properties)
+      properties.nil? || !properties.is_a?(Hash) || properties[Labimotion::Prop::LAYERS].nil? || properties[Labimotion::Prop::LAYERS].keys.empty?
+    end
+
+    def self.detach(properties, key, type)
+      fields = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].select { |ss| ss['type'] == type }
+      fields.each do |field|
+        next unless check_val(field, type)
+
+        properties = detach_val(properties, field, key, type)
+      end
+      properties
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      properties
+    end
+
+    def self.split(properties, key, type)
+      fields = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].select { |ss| ss['type'] == type }
+      fields.each do |field|
+        next unless check_val(field, type)
+
+        idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
+        ## TODO Split ...
+      end
+      properties
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      properties
+    end
+
+    def self.copy(properties, key, type)
+      fields = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].select { |ss| ss['type'] == type }
+      fields.each do |field|
+        next unless check_val(field, type)
+
+        idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
+        ## TODO Copy Sample...
+      end
+      properties
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      properties
+    end
+  end
+end

data/lib/labimotion/libs/sample_association.rb

@@ -34,9 +34,9 @@ module Labimotion
     def self.build_table_sample(field_tables, current_user, element = nil)
       sds = []
       field_tables.each do |field|
-        next unless field['sub_values'].present? && field['sub_fields'].present?
+        next unless field['sub_values'].present? && field[Labimotion::Prop::SUBFIELDS].present?
 
-        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 }
         next unless field_table_samples.present?
 
         col_ids = field_table_samples.map { |x| x.values[0] }
@@ -73,33 +73,33 @@ module Labimotion
     def self.update_sample_association(properties, current_user, element = nil)
       sds = []
       els = []
-      properties['layers'].keys.each do |key|
-        layer = properties['layers'][key]
-        field_samples = layer['fields'].select { |ss| ss['type'] == 'drag_sample' }
+      properties[Labimotion::Prop::LAYERS].keys.each do |key|
+        layer = properties[Labimotion::Prop::LAYERS][key]
+        field_samples = layer[Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_SAMPLE }
         field_samples.each do |field|
-          idx = properties['layers'][key]['fields'].index(field)
+          idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
           sid = field.dig('value', 'el_id')
           next if sid.blank?
 
-          sds << sid unless properties.dig('layers', key, 'fields', idx, 'value', 'is_new') == true
-          next unless properties.dig('layers', key, 'fields', idx, 'value', 'is_new') == true
+          sds << sid unless properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value', 'is_new') == true
+          next unless properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value', 'is_new') == true
 
           cr_opt = field.dig('value', 'cr_opt')
           subsample = Labimotion::SampleAssociation.build_sample(sid, element&.collections, current_user, cr_opt) unless sid.nil? || cr_opt.nil?
           next if subsample.nil?
 
           sds << subsample.id
-          properties['layers'][key]['fields'][idx]['value']['el_id'] = subsample.id
-          properties['layers'][key]['fields'][idx]['value']['el_label'] = subsample.short_label
-          properties['layers'][key]['fields'][idx]['value']['el_tip'] = subsample.short_label
-          properties['layers'][key]['fields'][idx]['value']['is_new'] = false
+          properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_id'] = subsample.id
+          properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_label'] = subsample.short_label
+          properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_tip'] = subsample.short_label
+          properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['is_new'] = false
           Labimotion::ElementsSample.find_or_create_by(element_id: element.id, sample_id: subsample.id) if element.present?
         end
-        field_tables = properties['layers'][key]['fields'].select { |ss| ss['type'] == 'table' }
+        field_tables = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::TABLE }
         sds << Labimotion::SampleAssociation.build_table_sample(field_tables, current_user, element) if element.present?
-        field_elements = layer['fields'].select { |ss| ss['type'] == 'drag_element' }
+        field_elements = layer[Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_ELEMENT }
         field_elements.each do |field|
-          idx = properties['layers'][key]['fields'].index(field)
+          idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
           sid = field.dig('value', 'el_id')
           next if element.nil? || sid.blank? || sid == element.id
 

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

@@ -15,7 +15,7 @@ module Labimotion
       if properties_release['flowObject'].present?
         elements = (properties_release['flowObject']['nodes'] || []).map do |el|
           if el['data'].present? && el['data']['lKey'].present?
-            layer = properties_release['layers'][el['data']['lKey']]
+            layer = properties_release[Labimotion::Prop::LAYERS][el['data']['lKey']]
             el['data']['layer'] = layer if layer.present?
           end
           el

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

@@ -28,9 +28,9 @@ module Labimotion
 
     def delete_attachments
       att_ids = []
-      properties && properties['layers']&.keys&.each do |key|
-        layer = properties['layers'][key]
-        field_uploads = layer['fields'].select { |ss| ss['type'] == 'upload' }
+      properties && 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 |field|
           (field['value'] && field['value']['files'] || []).each do |file|
             att_ids.push(file['aid']) unless file['aid'].nil?

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

@@ -0,0 +1,18 @@
+module Labimotion
+  # Segmentable concern
+  module LinkedProperties
+    extend ActiveSupport::Concern
+
+    def detach_properties(properties)
+      return properties if Labimotion::PropertiesHandler.check_properties(properties)
+
+      properties[Labimotion::Prop::LAYERS]&.keys&.each do |key|
+        properties = Labimotion::PropertiesHandler.detach(properties, key, Labimotion::FieldType::DRAG_SAMPLE)
+        properties = Labimotion::PropertiesHandler.detach(properties, key, Labimotion::FieldType::DRAG_ELEMENT)
+        properties = Labimotion::PropertiesHandler.detach(properties, key, Labimotion::FieldType::UPLOAD)
+        properties = Labimotion::PropertiesHandler.detach(properties, key, Labimotion::FieldType::TABLE)
+      end
+      properties
+    end
+  end
+end

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

@@ -16,21 +16,26 @@ module Labimotion
       segments = save_segments(segments: args[:segments], current_user_id: args[:current_user_id])
       segments.each do |segment|
         properties = segment.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|
-              aid = properties['layers'][key]['fields'][idx]['value']['files'][fdx]['aid']
-              unless aid.nil?
-                copied_att = Attachment.find(aid)&.copy(attachable_type: 'SegmentProps', attachable_id: segment.id, transferred: true)
-                unless copied_att.nil?
-                  copied_att.save!
-                  properties['layers'][key]['fields'][idx]['value']['files'][fdx]['aid'] = copied_att.id
-                  properties['layers'][key]['fields'][idx]['value']['files'][fdx]['uid'] = copied_att.identifier
-                end
+              aid = files[fdx]['aid']
+              uid = files[fdx]['uid']
+              next if aid.nil?
+
+              att = Attachment.find_by(id: aid)
+              att = Attachment.find_by(identifier: uid) if att.nil?
+              copied_att = att&.copy(attachable_type: Labimotion::Prop::SEGMENTPROPS, attachable_id: segment.id, transferred: true)
+              if copied_att.nil?
+                properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['files'].delete_at(fdx)
+              else
+                copied_att.save!
+                properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['files'][fdx]['aid'] = copied_att.id
+                properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['files'][fdx]['uid'] = copied_att.identifier
               end
             end
           end

data/lib/labimotion/models/element.rb

@@ -2,19 +2,20 @@
 require 'labimotion/models/concerns/generic_revisions'
 require 'labimotion/models/concerns/segmentable'
 require 'labimotion/models/concerns/workflow'
+require 'labimotion/models/concerns/linked_properties'
 
 module Labimotion
   class Element < ApplicationRecord
     acts_as_paranoid
     self.table_name = :elements
-    include PgSearch if Labimotion::IS_RAILS5 == true
-    include PgSearch::Model if Labimotion::IS_RAILS5 == false
+    include PgSearch::Model
     include ElementUIStateScopes
     include Collectable
     include Taggable
     include Workflow
     include Segmentable
     include GenericRevisions
+    include LinkedProperties
 
     multisearchable against: %i[name short_label]
 
@@ -30,6 +31,8 @@ module Labimotion
 
     belongs_to :element_klass, class_name: 'Labimotion::ElementKlass'
 
+    has_ancestry orphan_strategy: :adopt
+
     has_many :collections_elements,  inverse_of: :element, dependent: :destroy, class_name: 'Labimotion::CollectionsElement'
     has_many :collections, through: :collections_elements
     has_many :attachments, as: :attachable
@@ -51,7 +54,7 @@ module Labimotion
     has_many :elements_elements, foreign_key: :parent_id, class_name: 'Labimotion::ElementsElement'
     has_many :elements, through: :elements_elements, source: :element, class_name: 'Labimotion::Element'
 
-    before_create :auto_set_short_label
+    before_save :auto_set_short_label
     after_create :update_counter
     before_destroy :delete_attachment
 
@@ -69,6 +72,10 @@ module Labimotion
     end
 
     def auto_set_short_label
+      return if short_label && !short_label_changed?
+
+      return if parent && (self.short_label = "#{parent.short_label}-#{parent.children.with_deleted.count.to_i.succ}")
+
       prefix = element_klass.klass_prefix
       if creator.counters[element_klass.name].nil?
         creator.counters[element_klass.name] = '0'
@@ -99,22 +106,24 @@ module Labimotion
     end
 
     def thumb_svg
-      if Labimotion::IS_RAILS5 == true
-        image_atts = attachments.select do |a_img|
-          a_img&.content_type&.match(Regexp.union(%w[jpg jpeg png tiff tif]))
-        end
-
-        attachment = image_atts[0] || attachments[0]
-        preview = attachment.read_thumbnail if attachment
-        preview && Base64.encode64(preview) || 'not available'
-      else
-        image_atts = attachments.select(&:type_image?)
-        attachment = image_atts[0] || attachments[0]
-        preview = attachment&.read_thumbnail
-        (preview && Base64.encode64(preview)) || 'not available'
-      end
+      image_atts = attachments.select(&:type_image?)
+      attachment = image_atts[0] || attachments[0]
+      preview = attachment&.read_thumbnail
+      (preview && Base64.encode64(preview)) || 'not available'
     end
 
+    def split(user, col_ids)
+      subelement = self.dup
+      subelement.name = self.name if self.name.present?
+      subelement.parent = self
+      subelement.properties = detach_properties(properties)
+      subelement.created_by = user.id
+      collections = (Collection.where(id: col_ids) | Collection.where(user_id: user, label: 'All', is_locked: true))
+      subelement.collections << collections
+      subelement.container = Container.create_root_container
+      subelement.save!
+      subelement
+    end
 
     def migrate_workflow
       return if properties.nil? || properties_release.nil?

data/lib/labimotion/utils/export_utils.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class ExportUtils
+    class << self
+      private
+      def uid(uuids, key, id)
+        return nil if uuids.nil? || key.nil? || id.nil?
+
+        new_id = uuids.fetch(key, nil)&.fetch(id, nil)
+        new_id || id
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        raise
+      end
+
+      def el_type(name)
+        return nil if name.nil?
+
+        case name
+        when Labimotion::FieldType::DRAG_ELEMENT
+          Labimotion::Prop::L_ELEMENT
+        when Labimotion::FieldType::DRAG_SAMPLE
+          Labimotion::Prop::SAMPLE
+        when Labimotion::FieldType::DRAG_MOLECULE
+          Labimotion::Prop::MOLECULE
+        end
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        name
+      end
+
+      def fetch_molecule(type, id)
+        return if type != Labimotion::FieldType::DRAG_MOLECULE || id.nil?
+
+        molecule = Molecule.find_by(id: id)
+        yield(molecule) if molecule.present?
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        raise
+      end
+
+      def set_seg_prop(properties, uuids, key, type, &fetch_one)
+        layer = properties[Labimotion::Prop::LAYERS][key]
+        fields = layer[Labimotion::Prop::FIELDS].select { |ss| ss['type'] == type }
+        fields.each do |field|
+          idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
+          next unless field.fetch('value', nil).is_a?(Hash)
+
+          id = field.fetch('value', nil)&.fetch('el_id', nil) unless idx.nil?
+          next unless id.is_a?(Integer)
+          next if properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]&.fetch('value', nil).nil?
+          next unless properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'].is_a?(Hash)
+
+          properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_id'] = uid(uuids, el_type(type), id)
+        end
+        properties
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        properties
+      end
+
+      def set_prop(properties, uuids, key, type, &fetch_one)
+        layer = properties.fetch(Labimotion::Prop::LAYERS, nil)&.fetch(key, nil)
+        return properties if layer.nil?
+
+        fields = layer[Labimotion::Prop::FIELDS]&.select { |ss| ss['type'] == type }
+        fields&.each do |field|
+          idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
+          next unless field.fetch('value', nil).is_a?(Hash)
+
+          id = field.fetch('value', nil)&.fetch('el_id', nil) unless idx.nil?
+          fetch_molecule(type, id, &fetch_one)
+          next if properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]&.fetch('value', nil).nil?
+
+          next unless properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'].is_a?(Hash)
+
+          properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_id'] = uid(uuids, el_type(type), id)
+        end
+        properties
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        properties
+      end
+
+      def set_ai(instance, properties, uuids, key)
+        return properties unless instance.is_a?(Element)
+
+        layer = properties[Labimotion::Prop::LAYERS][key]
+        layer&.fetch('ai', nil)&.each_with_index do |ai, idx|
+          properties[Labimotion::Prop::LAYERS][key]['ai'][idx] = uid(uuids, Labimotion::Prop::CONTAINER, ai)
+        end
+        properties
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        properties
+      end
+
+      def set_upload(instance, properties, attachments, uuids, key, type)
+        attachments = [] if attachments.nil?
+        layer = properties[Labimotion::Prop::LAYERS][key]
+        fields = layer[Labimotion::Prop::FIELDS].select { |ss| ss['type'] == type }
+        fields.each do |field|
+          idx = properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
+          files = field.fetch('value', nil)&.fetch('files', nil)
+          files&.each_with_index do |fi, fdx|
+            att = Attachment.find_by(id: fi['aid'])
+            if att.nil?
+              properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['files'].delete_at(fdx)
+            else
+              attachments += [att] if att.present?
+              uuaid = yield(att, {'attachable_id' => instance.class.name})
+              properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['files'][fdx]['aid'] = uuaid unless att.nil?
+            end
+          end
+          id = field.fetch('value', nil)&.fetch('el_id', nil) unless idx.nil?
+          if properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx].fetch('value', nil).is_a?(Hash)
+            properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_id'] = uid(uuids, el_type(type), id)
+          end
+        end
+        [properties, attachments]
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        [properties, attachments]
+      end
+
+
+      def set_table_prop(field, uuids, type, &fetch_one)
+        fields = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == type }
+        return field if fields.empty?
+
+        col_ids = fields.map { |x| x.values[0] }
+        col_ids&.each do |col_id|
+          field['sub_values'].each do |sub_value|
+            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?
+            next unless id = sub_value[col_id]['value']['el_id']
+
+            fetch_molecule(type, id, &fetch_one)
+            sub_value[col_id]['value']['el_id'] = uid(uuids, el_type(type), id)
+          end
+        end
+        field
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        field
+      end
+
+      def set_table(properties, uuids, key, type, &fetch_one)
+        layer = properties[Labimotion::Prop::LAYERS][key]
+        fields = layer[Labimotion::Prop::FIELDS].select { |ss| ss['type'] == type }
+        fields&.each do |field|
+          next unless field['sub_values'].present? && field[Labimotion::Prop::SUBFIELDS].present?
+
+          set_table_prop(field, uuids, Labimotion::FieldType::DRAG_MOLECULE, &fetch_one)
+          set_table_prop(field, uuids, Labimotion::FieldType::DRAG_SAMPLE, &fetch_one)
+        end
+        properties
+      rescue StandardError => e
+        Labimotion.log_exception(e)
+        properties
+      end
+    end
+
+    def self.fetch_seg_properties(segment, uuids)
+      properties = segment['properties'] || {}
+      properties[Labimotion::Prop::LAYERS].keys.each do |key|
+        properties = set_seg_prop(properties, uuids, key, Labimotion::FieldType::DRAG_ELEMENT)
+        properties = set_seg_prop(properties, uuids, key, Labimotion::FieldType::DRAG_SAMPLE)
+      end
+      segment['properties'] = properties
+      segment
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      segment
+    end
+
+    def self.fetch_properties(instance, uuids, attachments, &fetch_one)
+      attachments = [] if attachments.nil?
+      properties = instance.properties
+      properties[Labimotion::Prop::LAYERS].keys.each do |key|
+        properties = set_ai(instance, properties, uuids, key)
+        properties = set_prop(properties, uuids, key, Labimotion::FieldType::DRAG_ELEMENT, &fetch_one)
+        properties = set_prop(properties, uuids, key, Labimotion::FieldType::DRAG_MOLECULE, &fetch_one)
+        properties = set_prop(properties, uuids, key, Labimotion::FieldType::DRAG_SAMPLE, &fetch_one)
+        properties, attachments = set_upload(instance, properties, attachments, uuids, key, Labimotion::FieldType::UPLOAD, &fetch_one)
+        properties = set_table(properties, uuids, key, Labimotion::FieldType::TABLE, &fetch_one)
+      end
+      instance.properties = properties
+      [instance, attachments]
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      [instance, attachments]
+    end
+  end
+end

data/lib/labimotion/utils/field_type.rb

@@ -0,0 +1,23 @@
+module Labimotion
+  ## Properties Field Type
+  class FieldType
+    CHECKBOX = 'checkbox'.freeze
+    DATE = 'date'.freeze
+    DATETIME = 'datetime'.freeze
+    DATETIME_RANGE = 'datetime-range'.freeze
+    SELECT = 'select'.freeze
+    INTEGER = 'integer'.freeze
+    SYSTEM_DEFINED = 'system-defined'.freeze
+    DRAG = 'drag'.freeze
+    DRAG_ELEMENT = 'drag_element'.freeze
+    DRAG_MOLECULE = 'drag_molecule'.freeze
+    DRAG_SAMPLE = 'drag_sample'.freeze
+    DRAG_REACTION = 'drag_reaction'.freeze
+    DRAG_MS = [DRAG_MOLECULE, DRAG_SAMPLE].freeze
+    DRAG_ALL = [DRAG_ELEMENT, DRAG_MOLECULE, DRAG_SAMPLE, DRAG_REACTION].freeze
+    TABLE = 'table'.freeze
+    UPLOAD = 'upload'.freeze
+    TEXT = 'text'.freeze
+    TEXTAREA = 'textarea'.freeze
+  end
+end