labimotion 0.1.6

data/lib/labimotion/helpers/dataset_helpers.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require 'grape'
+module Labimotion
+    ## DatasetHelpers
+  module DatasetHelpers
+    extend Grape::API::Helpers
+
+    def klass_list(is_active)
+      if is_active == true
+        Labimotion::DatasetKlass.where(is_active: true).order('place') || []
+      else
+        Labimotion::DatasetKlass.all.order('place') || []
+      end
+    end
+
+    def create_repo_klass(params, current_user)
+      response = Labimotion::TemplateHub.fetch_identifier('DatasetKlass', params[:identifier])
+      attributes = response.slice('ols_term_id', 'label', 'desc', 'uuid', 'identifier') # .except(:id, :is_active, :place, :created_by, :created_at, :updated_at)
+      attributes['properties_template'] = response['properties_release']
+      attributes['place'] = ((Labimotion::DatasetKlass.all.length * 10) || 0) + 10
+      attributes['is_active'] = false
+      attributes['updated_by'] = current_user.id
+      attributes['sync_by'] = current_user.id
+      attributes['sync_time'] = DateTime.now
+      if Labimotion::DatasetKlass.find_by(ols_term_id: attributes['ols_term_id']).present?
+        ds = Labimotion::DatasetKlass.find_by(ols_term_id: attributes['ols_term_id'])
+        ds.update!(attributes)
+      else
+        attributes['created_by'] = current_user.id
+        Labimotion::DatasetKlass.create!(attributes)
+      end
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      # { error: e.message }
+      raise e
+    end
+  end
+end

data/lib/labimotion/helpers/element_helpers.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require 'grape'
+require 'labimotion/version'
+# require 'labimotion/models/element_klass'
+module Labimotion
+  ## ElementHelpers
+  module ElementHelpers
+    extend Grape::API::Helpers
+
+    def klass_list(is_generic_only)
+      if is_generic_only == true
+        Labimotion::ElementKlass.where(is_active: true, is_generic: true).order('place') || []
+      else
+        Labimotion::ElementKlass.where(is_active: true).order('place') || []
+      end
+    end
+
+    def create_element_klass(current_user, params)
+      uuid = SecureRandom.uuid
+      template = { uuid: uuid, layers: {}, select_options: {} }
+      attributes = declared(params, include_missing: false)
+      attributes[:properties_template]['uuid'] = uuid if attributes[:properties_template].present?
+      attributes[:properties_template] = template unless attributes[:properties_template].present?
+      attributes[:properties_template]['eln'] = Chemotion::Application.config.version if attributes[:properties_template].present?
+      attributes[:properties_template]['labimotion'] = Labimotion::VERSION if attributes[:properties_template].present?
+      attributes[:properties_template]['klass'] = 'ElementKlass' if attributes[:properties_template].present?
+      attributes[:is_active] = false
+      attributes[:uuid] = uuid
+      attributes[:released_at] = DateTime.now
+      attributes[:properties_release] = attributes[:properties_template]
+      attributes[:created_by] = current_user.id
+
+      new_klass = Labimotion::ElementKlass.create!(attributes)
+      new_klass.reload
+      new_klass.create_klasses_revision(current_user.id)
+      klass_names_file = Rails.root.join('config', 'klasses.json')
+      klasses = Labimotion::ElementKlass.where(is_active: true)&.pluck(:name) || []
+      File.write(klass_names_file, klasses)
+      klasses
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def update_element_klass(current_user, params)
+      place = params[:place] || 100
+      begin
+        place = place.to_i if place.present? && place.to_i == place.to_f
+      rescue StandardError
+        place = 100
+      end
+      klass = Labimotion::ElementKlass.find(params[:id])
+      klass.label = params[:label] if params[:label].present?
+      klass.klass_prefix = params[:klass_prefix] if params[:klass_prefix].present?
+      klass.icon_name = params[:icon_name] if params[:icon_name].present?
+      klass.desc = params[:desc] if params[:desc].present?
+      klass.place = place
+      klass.save!
+      klass
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def create_element(current_user, params)
+      klass = params[:element_klass] || {}
+      uuid = SecureRandom.uuid
+      params[:properties]['uuid'] = uuid
+      params[:properties]['klass_uuid'] = klass[:uuid]
+      params[:properties]['eln'] = Chemotion::Application.config.version
+      params[:properties]['labimotion'] = Labimotion::VERSION
+      params[:properties]['klass'] = 'Element'
+      properties = params[:properties]
+      properties.delete('flow') unless properties['flow'].nil?
+      properties.delete('select_options') unless properties['select_options'].nil?
+      attributes = {
+        name: params[:name],
+        element_klass_id: klass[:id],
+        uuid: uuid,
+        klass_uuid: klass[:uuid],
+        properties: properties,
+        properties_release: params[:properties_release],
+        created_by: current_user.id,
+      }
+      element = Labimotion::Element.new(attributes)
+
+      if params[:collection_id]
+        collection = current_user.collections.find(params[:collection_id])
+        element.collections << collection
+      end
+      all_coll = Collection.get_all_collection_for_user(current_user.id)
+      element.collections << all_coll
+      element.save!
+      element.properties = update_sample_association(element, params[:properties], current_user)
+      element.container = update_datamodel(params[:container], current_user)
+      element.save!
+      element.save_segments(segments: params[:segments], current_user_id: current_user.id)
+      element
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def update_element_by_id(current_user, params)
+      element = Labimotion::Element.find(params[:id])
+      update_datamodel(params[:container], current_user)
+      properties = update_sample_association(element, params[:properties], current_user)
+      params.delete(:container)
+      params.delete(:properties)
+      attributes = declared(params.except(:segments), include_missing: false)
+      properties['eln'] = Chemotion::Application.config.version
+      properties['labimotion'] = Labimotion::VERSION
+      if element.klass_uuid != properties['klass_uuid'] || element.properties != properties || element.name != params[:name]
+        properties['klass'] = 'Element'
+        uuid = SecureRandom.uuid
+        properties['uuid'] = uuid
+
+        properties.delete('flow') unless properties['flow'].nil?
+        properties.delete('select_options') unless properties['select_options'].nil?
+
+        attributes['properties'] = properties
+        attributes['properties']['uuid'] = uuid
+        attributes['uuid'] = uuid
+        attributes['klass_uuid'] = properties['klass_uuid']
+
+        element.update(attributes)
+      end
+      element.save_segments(segments: params[:segments], current_user_id: current_user.id)
+      element
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def upload_generics_files(current_user, params)
+      attach_ary = []
+      att_ary = create_uploads(
+        'Element',
+        params[:att_id],
+        params[:elfiles],
+        params[:elInfo],
+        current_user.id,
+      ) if params[:elfiles].present? && params[:elInfo].present?
+
+      (attach_ary << att_ary).flatten! unless att_ary&.empty?
+
+      att_ary = create_uploads(
+        'Segment',
+        params[:att_id],
+        params[:sefiles],
+        params[:seInfo],
+        current_user.id
+      ) if params[:sefiles].present? && params[:seInfo].present?
+
+      (attach_ary << att_ary).flatten! unless att_ary&.empty?
+
+      if params[:attfiles].present? || params[:delfiles].present? then
+        att_ary = create_attachments(
+          params[:attfiles],
+          params[:delfiles],
+          params[:att_type],
+          params[:att_id],
+          params[:attfilesIdentifier],
+          current_user.id
+        )
+      end
+      (attach_ary << att_ary).flatten! unless att_ary&.empty?
+
+      if Labimotion::IS_RAILS5 == true
+        TransferThumbnailToPublicJob.set(queue: "transfer_thumbnail_to_public_#{current_user.id}").perform_now(attach_ary) unless attach_ary.empty?
+        TransferFileFromTmpJob.set(queue: "transfer_file_from_tmp_#{current_user.id}").perform_now(attach_ary) unless attach_ary.empty?
+      end
+      true
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      ## false
+      raise e
+    end
+
+    def element_revisions(params)
+      klass = Labimotion::Element.find(params[:id])
+      list = klass.elements_revisions unless klass.nil?
+      list&.sort_by(&:created_at)&.reverse
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def list_user_elements(scope, params)
+      from = params[:from_date]
+      to = params[:to_date]
+      by_created_at = params[:filter_created_at] || false
+
+      if params[:sort_column]&.include?('.')
+        layer, field = params[:sort_column].split('.')
+
+        element_klass = Labimotion::ElementKlass.find_by(name: params[:el_type])
+        allowed_fields = element_klass.properties_release.dig('layers', layer, 'fields')&.pluck('field') || []
+
+        if field.in?(allowed_fields)
+          query = ActiveRecord::Base.sanitize_sql(
+            [
+              "LEFT JOIN LATERAL(
+                SELECT field->'value' AS value
+                FROM jsonb_array_elements(properties->'layers'->:layer->'fields') a(field)
+                WHERE field->>'field' = :field
+              ) a ON true",
+              { layer: layer, field: field },
+            ],
+          )
+          scope = scope.joins(query).order('value ASC NULLS FIRST')
+        else
+          scope = scope.order(updated_at: :desc)
+        end
+      else
+        scope = scope.order(updated_at: :desc)
+      end
+
+      scope = scope.created_time_from(Time.at(from)) if from && by_created_at
+      scope = scope.created_time_to(Time.at(to) + 1.day) if to && by_created_at
+      scope = scope.updated_time_from(Time.at(from)) if from && !by_created_at
+      scope = scope.updated_time_to(Time.at(to) + 1.day) if to && !by_created_at
+      scope
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def list_serialized_elements(params, current_user)
+      collection_id =
+      if params[:collection_id]
+        Collection
+          .belongs_to_or_shared_by(current_user.id, current_user.group_ids)
+          .find_by(id: params[:collection_id])&.id
+      elsif params[:sync_collection_id]
+        current_user
+          .all_sync_in_collections_users
+          .find_by(id: params[:sync_collection_id])&.collection&.id
+      end
+
+      scope =
+      if collection_id
+        Labimotion::Element
+          .joins(:element_klass, :collections_elements)
+          .where(
+            element_klasses: { name: params[:el_type] },
+            collections_elements: { collection_id: collection_id },
+          ).includes(:tag, collections: :sync_collections_users).order('created_at DESC')
+      else
+        Labimotion::Element.none
+      end
+
+      ## TO DO: refactor labimotion
+      from = params[:from_date]
+      to = params[:to_date]
+      by_created_at = params[:filter_created_at] || false
+      scope = scope.created_time_from(Time.at(from)) if from && by_created_at
+      scope = scope.created_time_to(Time.at(to) + 1.day) if to && by_created_at
+      scope = scope.updated_time_from(Time.at(from)) if from && !by_created_at
+      scope = scope.updated_time_to(Time.at(to) + 1.day) if to && !by_created_at
+      scope
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+  end
+end

data/lib/labimotion/helpers/generic_helpers.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+require 'grape'
+require 'labimotion/version'
+# Helper for associated sample
+module Labimotion
+  ## Generic Helpers
+  module GenericHelpers
+    extend Grape::API::Helpers
+
+    def authenticate_admin!(type)
+      error!('401 Unauthorized', 401) unless current_user.generic_admin[type]
+    end
+
+    def fetch_klass(name, id)
+      klz = "Labimotion::#{name}".constantize.find_by(id: id)
+      error!("#{name.gsub(/(Klass)/, '')} is invalid. Please re-select.", 500) if klz.nil?
+      klz
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def deactivate_klass(params)
+      klz = fetch_klass(params[:klass], params[:id])
+      klz&.update!(is_active: params[:is_active])
+      generate_klass_file unless klz.class.name != 'ElementKlass'
+      klz
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def delete_klass(params)
+      authenticate_admin!(params[:klass].gsub(/(Klass)/, 's').downcase)
+      klz = fetch_klass(params[:klass], params[:id])
+      klz&.destroy!
+      generate_klass_file unless klz.class.name != 'ElementKlass'
+      status 201
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def update_template(params)
+      klz = fetch_klass(params[:klass], params[:id])
+      uuid = SecureRandom.uuid
+      properties = params[:properties_template]
+      if Labimotion::IS_RAILS5 == false
+        properties['uuid'] = uuid unless params[:is_release] == true && @klz.identifier.present?
+      else
+        properties['uuid'] = uuid
+      end
+      properties['eln'] = Chemotion::Application.config.version
+      properties['labimotion'] = Labimotion::VERSION
+      properties['klass'] = @klz.class.name
+      klz.updated_by = current_user.id
+      klz.properties_template = properties
+      klz.save!
+      klz.reload
+      klz.create_klasses_revision(current_user.id) if params[:is_release] == true
+      klz
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def delete_klass_revision(params)
+      revision = "Labimotion::#{params[:klass]}esRevision".constantize.find(params[:id])
+      klass = "Labimotion::#{params[:klass]}".constantize.find_by(id: params[:klass_id]) unless revision.nil?
+      error!('Revision is invalid.', 404) if revision.nil?
+      error!('Can not delete the active revision.', 405) if revision.uuid == klass.uuid
+      revision&.destroy!
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def delete_revision(params)
+      revision = "Labimotion::#{params[:klass]}sRevision".constantize.find(params[:id])
+      element = "Labimotion::#{params[:klass]}".constantize.find_by(id: params[:element_id]) unless revision.nil?
+      error!('Revision is invalid.', 404) if revision.nil?
+      error!('Can not delete the active revision.', 405) if revision.uuid == element.uuid
+      revision&.destroy!
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def list_klass_revisions(params)
+      klass = "Labimotion::#{params[:klass]}".constantize.find_by(id: params[:id])
+      list = klass.send("#{params[:klass].underscore}es_revisions") unless klass.nil?
+      list.sort_by(&:released_at).reverse
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+
+    ###############
+
+
+    def generate_klass_file
+      klass_dir = File.join(Rails.root, 'data')
+      !File.directory?(klass_dir) && FileUtils.mkdir_p(klass_dir)
+      klass_names_file = File.join(klass_dir, 'klasses.json')
+      klasses = Labimotion::ElementKlass.where(is_active: true)&.pluck(:name) || []
+      File.write(klass_names_file, klasses)
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def fetch_properties_uploads(properties)
+      uploads = []
+      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|
+            uploads.push({ layer: key, field: field['field'], uid: file['uid'], filename: file['filename'] })
+          end
+        end
+      end
+      uploads
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def update_properties_upload(element, properties, att, pa)
+      return if pa.nil?
+
+      idx = properties['layers'][pa[:layer]]['fields'].index { |fl| fl['field'] == pa[:field] }
+      fidx = properties['layers'][pa[:layer]]['fields'][idx]['value']['files'].index { |fi| fi['uid'] == pa[:uid] }
+      properties['layers'][pa[:layer]]['fields'][idx]['value']['files'][fidx]['aid'] = att.id
+      properties['layers'][pa[:layer]]['fields'][idx]['value']['files'][fidx]['uid'] = att.identifier
+      element.update_columns(properties: properties)
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def create_uploads(type, id, files, param_info, user_id)
+      return if files.nil? || param_info.nil? || files.empty? || param_info.empty?
+
+      attach_ary = []
+      map_info = JSON.parse(param_info)
+      map_info&.keys&.each do |key|
+        next if map_info[key]['files'].empty?
+
+        if type == 'Segment'
+          element = Labimotion::Segment.find_by(element_id: id, segment_klass_id: key)
+        elsif type == 'Element'
+          element = Labimotion::Element.find_by(id: id)
+        end
+        next if element.nil?
+
+        uploads = fetch_properties_uploads(element.properties)
+
+        map_info[key]['files'].each do |fobj|
+          file = (files || []).select { |ff| ff['filename'] == fobj['uid'] }&.first
+          pa = uploads.select { |ss| ss[:uid] == file[:filename] }&.first || nil
+          next unless (tempfile = file[:tempfile])
+
+          a = Attachment.new(
+            bucket: file[:container_id],
+            filename: fobj['filename'],
+            con_state: Labimotion::ConState::NONE,
+            file_path: file[:tempfile],
+            created_by: user_id,
+            created_for: user_id,
+            content_type: file[:type],
+            attachable_type: map_info[key]['type'],
+            attachable_id: element.id,
+          )
+          begin
+            a.save!
+
+            update_properties_upload(element, element.properties, a, pa)
+            attach_ary.push(a.id)
+          ensure
+            tempfile.close
+            tempfile.unlink
+          end
+        end
+        element.send("#{type.downcase}s_revisions")&.last&.destroy!
+        element.save!
+      end
+      attach_ary
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      error!('Error while uploading files.', 500)
+      raise e
+    end
+
+    def create_attachments(files, del_files, type, id, user_id)
+      attach_ary = []
+      (files || []).each do |file|
+        next unless (tempfile = file[:tempfile])
+
+        a = Attachment.new(
+          bucket: file[:container_id],
+          filename: file[:filename],
+          con_state: Labimotion::ConState::NONE,
+          file_path: file[:tempfile],
+          created_by: user_id,
+          created_for: user_id,
+          content_type: file[:type],
+          attachable_type: type,
+          attachable_id: id,
+        )
+        begin
+          a.save!
+          attach_ary.push(a.id)
+        ensure
+          tempfile.close
+          tempfile.unlink
+        end
+      end
+      unless (del_files || []).empty?
+        Attachment.where('id IN (?) AND attachable_type = (?)', del_files.map!(&:to_i),
+                        type).update_all(attachable_id: nil)
+      end
+      attach_ary
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def fetch_repo_generic_template(klass, identifier)
+      Chemotion::Generic::Fetch::Template.exec(API::TARGET, klass, identifier)
+    end
+
+    def fetch_repo_generic_template_list(name = false)
+      Chemotion::Generic::Fetch::Template.list(API::TARGET, name)
+    end
+
+    def fetch_repo(name)
+      current_klasses = "Labimotion::#{name}".constantize.where.not(identifier: nil)&.pluck(:identifier) || []
+      response = Labimotion::TemplateHub.list(name)
+      if response && response['list'].present? && response['list'].length.positive?
+        filter_list = response['list']&.reject do |ds|
+          current_klasses.include?(ds['identifier'])
+        end || []
+      end
+      filter_list || []
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+  end
+end

data/lib/labimotion/helpers/repository_helpers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require 'grape'
+
+module Labimotion
+  ## RepositoryHelpers
+  module RepositoryHelpers
+    extend Grape::API::Helpers
+
+    def copy_datsets(**args)
+      return if args[:dataset].nil?
+
+    end
+  end
+end

data/lib/labimotion/helpers/sample_association_helpers.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Helper for associated sample
+  module SampleAssociationHelpers
+    extend Grape::API::Helpers
+
+    def build_sample(sid, cols, current_user, cr_opt)
+      parent_sample = Sample.find(sid)
+
+      case cr_opt
+      when 0
+        subsample = parent_sample
+        collections = Collection.where(id: cols).where.not(id: subsample.collections.pluck(:id))
+        subsample.collections << collections unless collections.empty?
+      when 1
+        subsample = parent_sample.create_subsample(current_user, cols, true)
+      when 2
+        subsample = parent_sample.dup
+        subsample.parent = nil
+        collections = (Collection.where(id: cols) | Collection.where(user_id: current_user.id, label: 'All', is_locked: true))
+        subsample.collections << collections
+        subsample.container = Container.create_root_container
+      else
+        return nil
+      end
+
+      return nil if subsample.nil?
+
+      subsample.save!
+      subsample.reload
+      subsample
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      nil
+    end
+
+    def build_table_sample(element, field_tables)
+      sds = []
+      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' }
+        next unless field_table_samples.present?
+
+        col_ids = field_table_samples.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']
+            sid = svalue['el_id']
+            next unless sid.present?
+
+            sds << sid unless svalue['is_new']
+            next unless svalue['is_new']
+
+            cr_opt = svalue['cr_opt']
+
+            subsample = build_sample(sid, element.collections, current_user, cr_opt) unless sid.nil? || cr_opt.nil?
+            next if subsample.nil?
+
+            sds << subsample.id
+            sub_value[col_id]['value']['el_id'] = subsample.id
+            sub_value[col_id]['value']['is_new'] = false
+            Labimotion::ElementsSample.find_or_create_by(element_id: element.id, sample_id: subsample.id)
+          end
+        end
+      end
+      sds
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      []
+    end
+
+    def update_sample_association(element, properties, current_user)
+      sds = []
+      els = []
+      properties['layers'].keys.each do |key|
+        layer = properties['layers'][key]
+        field_samples = layer['fields'].select { |ss| ss['type'] == 'drag_sample' }
+        field_samples.each do |field|
+          idx = properties['layers'][key]['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
+
+          cr_opt = field.dig('value', 'cr_opt')
+
+          subsample = 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
+          Labimotion::ElementsSample.find_or_create_by(element_id: element.id, sample_id: subsample.id)
+        end
+        field_tables = properties['layers'][key]['fields'].select { |ss| ss['type'] == 'table' }
+        sds << build_table_sample(element, field_tables)
+
+        field_elements = layer['fields'].select { |ss| ss['type'] == 'drag_element' }
+        field_elements.each do |field|
+          idx = properties['layers'][key]['fields'].index(field)
+          sid = field.dig('value', 'el_id')
+          next if sid.blank? || sid == element.id
+
+          el = Labimotion::Element.find_by(id: sid)
+          next if el.nil?
+
+          Labimotion::ElementsElement.find_or_create_by(parent_id: element.id, element_id: el.id)
+          els << el.id
+        end
+
+      end
+      Labimotion::ElementsSample.where(element_id: element.id).where.not(sample_id: sds)&.destroy_all
+      Labimotion::ElementsElement.where(parent_id: element.id).where.not(element_id: els&.flatten)&.destroy_all
+      properties
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+    end
+  end
+end