labimotion 0.1.6

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Datasetable concern
+
+module Labimotion
+  ## Datasetable concern
+  module Datasetable
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :dataset, as: :element, class_name: 'Labimotion::Dataset'
+    end
+
+    def not_dataset?
+      self.class.name == 'Container' && container_type != 'dataset'
+    end
+
+    def save_dataset(**args)
+      return if not_dataset?
+
+      klass = Labimotion::DatasetKlass.find_by(id: args[:dataset_klass_id])
+      uuid = SecureRandom.uuid
+      props = args[:properties]
+      props['eln'] = Chemotion::Application.config.version
+      props['labimotion'] = Labimotion::VERSION
+      ds = Labimotion::Dataset.find_by(element_type: self.class.name, element_id: id)
+      if ds.present? && (ds.klass_uuid != props['klass_uuid'] || ds.properties != props)
+        props['uuid'] = uuid
+        props['eln'] = Chemotion::Application.config.version
+        props['labimotion'] = Labimotion::VERSION
+        props['klass'] = 'Dataset'
+        ds.update!(properties_release: klass.properties_release, uuid: uuid, dataset_klass_id: args[:dataset_klass_id], properties: props, klass_uuid: props['klass_uuid'])
+      end
+      return if ds.present?
+
+      props['uuid'] = uuid
+      props['klass_uuid'] = klass.uuid
+      props['eln'] = Chemotion::Application.config.version
+      props['labimotion'] = Labimotion::VERSION
+      props['klass'] = 'Dataset'
+      Labimotion::Dataset.create!(properties_release: klass.properties_release, uuid: uuid, dataset_klass_id: args[:dataset_klass_id], element_type: self.class.name, element_id: id, properties: props, klass_uuid: klass.uuid)
+    end
+
+    def destroy_datasetable
+      return if not_dataset?
+
+      Labimotion::Dataset.where(element_type: self.class.name, element_id: id).destroy_all
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Labimotion
+    module GenericKlassRevisions
+    extend ActiveSupport::Concern
+    included do
+      # has_many :element_klasses_revisions, dependent: :destroy
+    end
+
+    def create_klasses_revision(user_id=0)
+      properties_release = properties_template
+      # (properties_release['layers'] || {}).keys.each do |key|
+      #   properties_release['layers'][key]['layer'] = properties_release['layers'][key]['key']
+      # end
+
+      if properties_release['flow'].present?
+        elements = (properties_release['flow']['elements'] || []).map do |el|
+          if el['data'].present? && el['data']['lKey'].present?
+            layer = properties_release['layers'][el['data']['lKey']]
+            el['data']['layer'] = layer if layer.present?
+          end
+          el
+        end
+        properties_release['flow']['elements'] = elements
+      end
+
+      self.update!({ uuid: properties_template['uuid'], properties_release: properties_release, released_at: DateTime.now })
+      reload
+      attributes = {
+        released_by: user_id,
+        uuid: uuid,
+        properties_release: properties_release,
+        released_at: released_at
+      }
+      attributes["#{self.class.name.underscore.split('/').last}_id"] = id
+      "#{self.class.name}esRevision".constantize.create(attributes)
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# GenericRevisions concern
+module Labimotion
+  module GenericRevisions
+    extend ActiveSupport::Concern
+    included do
+      after_create :create_vault
+      after_update :save_to_vault
+      before_destroy :delete_attachments
+    end
+
+    def create_vault
+      save_to_vault unless self.class.name == 'Labimotion::Element'
+    end
+
+    def save_to_vault
+      attributes = {
+        uuid: uuid,
+        klass_uuid: klass_uuid,
+        properties: properties,
+        properties_release: properties_release
+      }
+      attributes["#{self.class.name.downcase.split('::').last}_id"] = id
+      attributes['name'] = name if self.class.name == 'Labimotion::Element'
+      "#{self.class.name}sRevision".constantize.create(attributes)
+    end
+
+    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' }
+        field_uploads.each do |field|
+          (field['value'] && field['value']['files'] || []).each do |file|
+            att_ids.push(file['aid']) unless file['aid'].nil?
+          end
+        end
+      end
+      Attachment.where(id: att_ids, attachable_id: id, attachable_type: %w[ElementProps SegmentProps]).destroy_all
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Segmentable concern
+  module Segmentable
+    extend ActiveSupport::Concern
+    included do
+      has_many :segments, as: :element, dependent: :destroy, class_name: 'Labimotion::Segment'
+    end
+
+    def copy_segments(**args)
+      return if args[:segments].nil?
+
+      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' }
+          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|
+              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
+              end
+            end
+          end
+        end
+        segment.update!(properties: properties)
+      end
+    end
+
+    def save_segments(**args) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      return if args[:segments].nil?
+
+      segments = []
+      args[:segments].each do |seg|
+        klass = Labimotion::SegmentKlass.find_by(id: seg['segment_klass_id'])
+        uuid = SecureRandom.uuid
+        props = seg['properties']
+        props['eln'] = Chemotion::Application.config.version
+        props['labimotion'] = Labimotion::VERSION
+        segment = Labimotion::Segment.find_by(element_type: self.class.name.split('::').last, element_id: self.id, segment_klass_id: seg['segment_klass_id'])
+        if segment.present? && (segment.klass_uuid != props['klass_uuid'] || segment.properties != props)
+          props['uuid'] = uuid
+          props['eln'] = Chemotion::Application.config.version
+          props['labimotion'] = Labimotion::VERSION
+          props['klass'] = 'Segment'
+
+          segment.update!(properties_release: klass.properties_release, properties: props, uuid: uuid, klass_uuid: props['klass_uuid'])
+          segments.push(segment)
+        end
+        next if segment.present?
+
+        props['uuid'] = uuid
+        props['klass_uuid'] = klass.uuid
+        props['eln'] = Chemotion::Application.config.version
+        props['labimotion'] = Labimotion::VERSION
+        props['klass'] = 'Segment'
+
+        segment = Labimotion::Segment.create!(properties_release: klass.properties_release, segment_klass_id: seg['segment_klass_id'], element_type: self.class.name.split('::').last, element_id: self.id, properties: props, created_by: args[:current_user_id], uuid: uuid, klass_uuid: klass.uuid)
+        segments.push(segment)
+      end
+      segments
+    end
+  end
+end

data/lib/labimotion/models/dataset.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require 'labimotion/models/concerns/generic_revisions'
+
+# ## This is the first version of the dataset class
+module Labimotion
+  # ## This is the first version of the dataset class
+  class Dataset < ApplicationRecord
+    self.table_name = :datasets
+    acts_as_paranoid
+    include GenericRevisions
+    belongs_to :dataset_klass, class_name: 'Labimotion::DatasetKlass'
+    belongs_to :element, polymorphic: true, class_name: 'Labimotion::Element'
+  end
+end

data/lib/labimotion/models/dataset_klass.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require 'labimotion/models/concerns/generic_klass_revisions'
+
+module Labimotion
+  class DatasetKlass < ApplicationRecord
+    acts_as_paranoid
+    self.table_name = :dataset_klasses
+    include GenericKlassRevisions
+    has_many :datasets, dependent: :destroy, class_name: 'Labimotion::Dataset'
+    has_many :dataset_klasses_revisions, dependent: :destroy, class_name: 'Labimotion::DatasetKlassesRevision'
+
+    def self.init_seeds
+      seeds_path = File.join(Rails.root, 'db', 'seeds', 'json', 'dataset_klasses.json')
+      seeds = JSON.parse(File.read(seeds_path))
+
+      seeds['chmo'].each do |term|
+        next if Labimotion::DatasetKlass.where(ols_term_id: term['id']).count.positive?
+
+        attributes = { ols_term_id: term['id'], label: "#{term['label']} (#{term['synonym']})", desc: "#{term['label']} (#{term['synonym']})", place: term['position'], created_by: Admin.first&.id || 0 }
+        Labimotion::DatasetKlass.create!(attributes)
+      end
+      true
+    end
+  end
+end

data/lib/labimotion/models/dataset_klasses_revision.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class DatasetKlassesRevision < ApplicationRecord
+    self.table_name = :dataset_klasses_revisions
+    acts_as_paranoid
+    has_one :dataset_klass, class_name: 'Labimotion::DatasetKlass'
+  end
+end

data/lib/labimotion/models/datasets_revision.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class DatasetsRevision < ApplicationRecord
+    acts_as_paranoid
+    self.table_name = :datasets_revisions
+    has_one :dataset, class_name: 'Labimotion::Dataset'
+  end
+end

data/lib/labimotion/models/element.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+require 'labimotion/models/concerns/generic_revisions'
+require 'labimotion/models/concerns/segmentable'
+
+module Labimotion
+  class Element < ApplicationRecord
+    acts_as_paranoid
+    self.table_name = :elements
+    include PgSearch
+    include ElementUIStateScopes
+    include Collectable
+    ## include AnalysisCodes
+    include Taggable
+    include Segmentable
+    include GenericRevisions
+
+    multisearchable against: %i[name short_label]
+
+    pg_search_scope :search_by_substring, against: %i[name short_label], using: { trigram: { threshold: 0.0001 } }
+
+    attr_accessor :can_copy
+
+    scope :by_name, ->(query) { where('name ILIKE ?', "%#{sanitize_sql_like(query)}%") }
+    scope :by_short_label, ->(query) { where('short_label ILIKE ?', "%#{sanitize_sql_like(query)}%") }
+    scope :by_klass_id_short_label, ->(klass_id, short_label) { where('element_klass_id = ? and short_label ILIKE ?', klass_id, "%#{sanitize_sql_like(short_label)}%") }
+    scope :by_sample_ids, ->(ids) { joins(:elements_samples).where('sample_id IN (?)', ids) }
+    scope :by_klass_id, ->(klass_id) { where('element_klass_id = ? ', klass_id) }
+
+    belongs_to :element_klass, class_name: 'Labimotion::ElementKlass'
+
+    has_many :collections_elements,  inverse_of: :element, dependent: :destroy, class_name: 'Labimotion::CollectionsElement'
+    has_many :collections, through: :collections_elements
+    has_many :attachments, as: :attachable
+    has_many :elements_samples, dependent: :destroy, class_name: 'Labimotion::ElementsSample'
+    has_many :samples, through: :elements_samples, source: :sample
+    has_one :container, :as => :containable
+    has_many :elements_revisions, dependent: :destroy, class_name: 'Labimotion::ElementsRevision'
+
+    accepts_nested_attributes_for :collections_elements
+
+    scope :elements_created_time_from, ->(time) { where('elements.created_at >= ?', time) }
+    scope :elements_created_time_to, ->(time) { where('elements.created_at <= ?', time) }
+    scope :elements_updated_time_from, ->(time) { where('elements.updated_at >= ?', time) }
+    scope :elements_updated_time_to, ->(time) { where('elements.updated_at <= ?', time) }
+
+    belongs_to :creator, foreign_key: :created_by, class_name: 'User'
+    validates :creator, presence: true
+
+    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
+    after_create :update_counter
+    before_destroy :delete_attachment
+
+
+    def attachments
+      Attachment.where(attachable_id: self.id, attachable_type: 'Element')
+    end
+
+    def self.get_associated_samples(element_ids)
+      Labimotion::ElementsSample.where(element_id: element_ids).pluck(:sample_id)
+    end
+
+    def analyses
+      container ? container.analyses : []
+    end
+
+    def auto_set_short_label
+      prefix = element_klass.klass_prefix
+      if creator.counters[element_klass.name].nil?
+        creator.counters[element_klass.name] = '0'
+        creator.update_columns(counters: creator.counters)
+        creator.reload
+      end
+      counter = creator.counters[element_klass.name].to_i.succ
+      self.short_label = "#{creator.initials}-#{prefix}#{counter}"
+    end
+
+    def update_counter
+      creator.increment_counter element_klass.name
+    end
+
+    def self.get_associated_elements(element_ids)
+      pids = Labimotion::Element.where(id: element_ids).pluck :id
+      get_ids = proc do |eids|
+        eids.each do |p|
+          cs = Labimotion::Element.find_by(id: p)&.elements.where.not(id: pids).pluck :id
+          next if cs.empty?
+
+          pids = (pids << cs).flatten.uniq
+          get_ids.call(cs)
+        end
+      end
+      get_ids.call(pids)
+      pids
+    end
+
+    def thumb_svg
+      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'
+    end
+
+    private
+
+    def delete_attachment
+      if Rails.env.production?
+        attachments.each do |attachment|
+          attachment.delay(run_at: 96.hours.from_now, queue: 'attachment_deletion').destroy!
+        end
+      else
+        attachments.each(&:destroy!)
+      end
+    end
+  end
+end

data/lib/labimotion/models/element_klass.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require 'labimotion/models/concerns/generic_klass_revisions'
+
+module Labimotion
+  class ElementKlass < ApplicationRecord
+    acts_as_paranoid
+    self.table_name = :element_klasses
+    include GenericKlassRevisions
+    has_many :elements, dependent: :destroy, class_name: 'Labimotion::Element'
+    has_many :segment_klasses, dependent: :destroy, class_name: 'Labimotion::SegmentKlass'
+    has_many :element_klasses_revisions, dependent: :destroy, class_name: 'Labimotion::ElementKlassesRevision'
+
+    def self.gen_klasses_json
+      klasses = where(is_active: true, is_generic: true).order('place')&.pluck(:name) || []
+    rescue ActiveRecord::StatementInvalid, PG::ConnectionBad, PG::UndefinedTable
+      klasses = []
+    ensure
+      File.write(
+        Rails.root.join('config', 'klasses.json'),
+        klasses&.to_json || []
+      )
+    end
+
+  end
+end

data/lib/labimotion/models/element_klasses_revision.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class ElementKlassesRevision < ApplicationRecord
+    acts_as_paranoid
+    self.table_name = :element_klasses_revisions
+    has_one :element_klass, class_name: 'Labimotion::ElementKlass'
+  end
+end

data/lib/labimotion/models/elements_element.rb

@@ -0,0 +1,11 @@
+
+module Labimotion
+  class ElementsElement < ApplicationRecord
+    self.table_name = :elements_elements
+    acts_as_paranoid
+    belongs_to :element, class_name: 'Labimotion::Element'
+    belongs_to :parent, foreign_key: :parent_id, class_name: 'Labimotion::Element'
+
+    # include Tagging
+  end
+end

data/lib/labimotion/models/elements_revision.rb

@@ -0,0 +1,8 @@
+
+module Labimotion
+  class ElementsRevision < ApplicationRecord
+    self.table_name = :elements_revisions
+    acts_as_paranoid
+    has_one :element, class_name: 'Labimotion::Element'
+  end
+end

data/lib/labimotion/models/elements_sample.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class ElementsSample < ApplicationRecord
+    acts_as_paranoid
+    self.table_name = :elements_samples
+    has_one :element, class_name: 'Labimotion::Element'
+    belongs_to :sample
+    include Tagging
+  end
+end

data/lib/labimotion/models/segment.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require 'labimotion/models/concerns/generic_revisions'
+
+module Labimotion
+  class Segment < ApplicationRecord
+    acts_as_paranoid
+    self.table_name = :segments
+    include GenericRevisions
+
+    belongs_to :segment_klass, class_name: 'Labimotion::SegmentKlass'
+    belongs_to :element, polymorphic: true, class_name: 'Labimotion::Element'
+    has_many :segments_revisions, dependent: :destroy, class_name: 'Labimotion::SegmentsRevision'
+  end
+end

data/lib/labimotion/models/segment_klass.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'labimotion/models/concerns/generic_klass_revisions'
+
+module Labimotion
+  class SegmentKlass < ApplicationRecord
+    self.table_name = :segment_klasses
+    acts_as_paranoid
+    include GenericKlassRevisions
+    belongs_to :element_klass, class_name: 'Labimotion::ElementKlass'
+    has_many :segments, dependent: :destroy, class_name: 'Labimotion::Segment'
+    has_many :segment_klasses_revisions, dependent: :destroy, class_name: 'Labimotion::SegmentKlassesRevision'
+
+    def self.gen_klasses_json
+      klasses = where(is_active: true)&.pluck(:name) || []
+    rescue ActiveRecord::StatementInvalid, PG::ConnectionBad, PG::UndefinedTable
+      klasses = []
+    ensure
+      File.write(
+        Rails.root.join('config', 'segment_klass.json'),
+        klasses&.to_json || []
+      )
+    end
+  end
+end

data/lib/labimotion/models/segment_klasses_revision.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class SegmentKlassesRevision < ApplicationRecord
+    acts_as_paranoid
+    self.table_name = :segment_klasses_revisions
+    has_one :segment_klass, class_name: 'Labimotion::SegmentKlass'
+  end
+end

data/lib/labimotion/models/segments_revision.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class SegmentsRevision < ApplicationRecord
+    acts_as_paranoid
+    self.table_name = :segments_revisions
+    has_one :segment, class_name: 'Labimotion::Segment'
+  end
+end

data/lib/labimotion/utils/con_state.rb

@@ -0,0 +1,13 @@
+module Labimotion
+  ## Converter State
+  class ConState
+    NONE = 0  ## Labimotion::ConState::NONE
+    WAIT = 1
+    NMR = 2
+    CONVERTED = 3
+    READ = 4
+    PROCESSED = 5
+    COMPLETED = 6
+    ERROR = 9
+  end
+end

data/lib/labimotion/utils/export.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+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'})
+    end
+
+    def self.fetch_segment_klasses(&fetch_many)
+      klasses = Labimotion::SegmentKlass.where(is_active: true)
+      fetch_many.call(klasses, {
+        'element_klass_id' => 'Labimotion::ElementKlass',
+        'created_by' => 'User'
+        })
+    end
+
+    def self.fetch_dataset_klasses(&fetch_many)
+      klasses = Labimotion::DatasetKlass.where(is_active: true)
+      fetch_many.call(klasses, {'created_by' => 'User'})
+    end
+
+
+    def self.fetch_segments(element, 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'
+        # })
+        fetch_one.call(segment, {
+          'element_id' => segment.element_type,
+          'segment_klass_id' => 'Labimotion::SegmentKlass',
+          'created_by' => 'User'
+        })
+      end
+      [segments, attachments]
+    end
+
+    def self.fetch_datasets(dataset, &fetch_one)
+      return if dataset.nil?
+
+      fetch_one.call(dataset, {
+        'element_id' => 'Container',
+      })
+      fetch_one.call(dataset, {
+        'element_id' => dataset.element_type,
+        '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_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]
+    end
+  end
+end