labimotion 1.4.1 → 2.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1c30f358902beeb863766ddb2ee02b980b3cca7055f45babe20fb4211277772
-  data.tar.gz: 86e1e46884b26fbfff1a91618698ab29072940109f9bc7c3d114b48a9b93ee86
+  metadata.gz: 608624a39eb174198e63db9cde2e4440425aa6bad1c604801c817ea13caea859
+  data.tar.gz: c691e2f9e670d301acc2494745e02836bf8ffcb1479c86c747f02ff9fadc6617
 SHA512:
-  metadata.gz: 41655a864b15b848116b370964ae6a05c707512d6ba80987cdec1f392d3fb647476fcf119612f116a2923c4992e32b00127371ac8a77d6e7de6cf1dc94773dbd
-  data.tar.gz: 8308707ad72ac2ebd38c725bc1336151712b5900fa4f35429674ee54f26cbe6fcc7ed43ef71777b6dd069701411540c776a7f183b183d147c1a3658a124e12a7
+  metadata.gz: e3c03f09293537ad8993158d1e1871fff2bf6a84ff88d90ca5d55af663fa862df4907a72639a2cdfb4bb7a2371911bf37b146cc97fbf0030945d3c23b5777de9
+  data.tar.gz: c746e80182b677d03c5bf06608285441a7b7022fdfcf521aec2aeaab61470d7a774ce059919d35e4b671446890b4055e3707da8b9a7f2fa52b4446fe52fbf655

data/lib/labimotion/apis/generic_element_api.rb

@@ -12,6 +12,7 @@ module Labimotion
     helpers CollectionHelpers
     helpers UserLabelHelpers
     helpers Labimotion::SampleAssociationHelpers
+    helpers Labimotion::VocabularyHelpers
     helpers Labimotion::GenericHelpers
     helpers Labimotion::ElementHelpers
     helpers Labimotion::ParamHelpers

data/lib/labimotion/apis/generic_klass_api.rb

@@ -6,7 +6,7 @@ require 'labimotion/libs/export_element'
 module Labimotion
   # Generic Element API
   class GenericKlassAPI < Grape::API
-    
+
     resource :generic_klass do
       namespace :download_klass do
         desc 'export klass'
@@ -28,7 +28,8 @@ module Labimotion
           Labimotion.log_exception(e, current_user)
           {}
         end
-      end      
+      end
+
     end
   end
 end

data/lib/labimotion/apis/labimotion_api.rb

@@ -0,0 +1,13 @@
+# app/api/labimotion/central_api.rb
+module Labimotion
+  class LabimotionAPI < Grape::API
+    mount Labimotion::ConverterAPI
+    mount Labimotion::GenericKlassAPI
+    mount Labimotion::GenericElementAPI
+    mount Labimotion::GenericDatasetAPI
+    mount Labimotion::SegmentAPI
+    mount Labimotion::LabimotionHubAPI
+    mount Labimotion::StandardLayerAPI
+    mount Labimotion::VocabularyAPI
+  end
+end

data/lib/labimotion/apis/standard_api.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'labimotion/version'
+require 'labimotion/libs/export_element'
+
+module Labimotion
+  # Generic Element API
+  class StandardAPI < Grape::API
+    resource :standards do
+      namespace :create_std_layer do
+        desc 'create standard layer'
+        params do
+          use :create_std_layer_params
+        end
+        post do
+          # authenticate_admin!('elements')
+          # create_element_klass(current_user, params)
+          create_std_layer(current_user, params)
+          status 201
+        rescue ActiveRecord::RecordInvalid => e
+          { error: e.message }
+        end
+      end
+    end
+  end
+end

data/lib/labimotion/apis/standard_layer_api.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'labimotion/version'
+
+module Labimotion
+  # Generic Element API
+  class StandardLayerAPI < Grape::API
+    include Grape::Kaminari
+    helpers Labimotion::ParamHelpers
+
+    resource :layers do
+      namespace :get_all_layers do
+        desc 'get all standard layers for designer'
+        get do
+          list = Labimotion::StdLayer.all.sort_by { |e| e.name }
+          # present list, with: Labimotion::StdLayer, root: 'klass'
+          # data = Labimotion::StdLayer.represent(col_tree, serializable: true)
+          return { mc: 'ss00', data: list }
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          { mc: 'se00', msg: e.message, data: [] }
+        end
+      end
+
+      namespace :get_standard_layer do
+        desc 'get standard layer by id'
+        # params do
+        #   requires :id, type: Integer, desc: 'Layer id'
+        # end
+        route_param :id do
+          before do
+          #   @element_policy = ElementPolicy.new(current_user, Labimotion::Element.find(params[:id]))
+          #   error!('401 Unauthorized', 401) unless current_user.matrix_check_by_name('genericElement') && @element_policy.read?
+          # rescue ActiveRecord::RecordNotFound
+          #   error!('404 Not Found', 404)
+          end
+          get do
+            entity = Labimotion::StdLayer.find(params[:id])
+            return { mc: 'ss00', data: entity }
+          rescue StandardError => e
+            Labimotion.log_exception(e, current_user)
+            { mc: 'se00', msg: e.message, data: {} }
+          end
+        end
+      end
+
+      namespace :save_standard_layer do
+        desc 'create Generic Element Klass'
+        params do
+          use :std_layer_save
+        end
+        before do
+          cur_layer = Labimotion::StdLayer.find_by(name: params[:key])
+          error!('Error! duplicate name', 409) if cur_layer.present?
+          # @element_policy = ElementPolicy.new(current_user, Labimotion::Element.find(params[:id]))
+          # error!('401 Unauthorized', 401) unless current_user.matrix_check_by_name('genericElement') && @element_policy.read?
+        # rescue ActiveRecord::RecordNotFound
+        #   Labimotion.log_exception(e, current_user)
+        #   error!('404 Not Found', 404)
+        end
+        post do
+          attributes = {
+            name: params[:key],
+            label: params[:label],
+            description: params[:description],
+            identifier: SecureRandom.uuid,
+            created_by: current_user.id,
+            properties: declared(params, include_missing: false)
+          }
+          layer = Labimotion::StdLayer.new(attributes)
+          layer.save!
+          { mc: 'ss00', data: layer }
+        rescue ActiveRecord::RecordInvalid => e
+          Labimotion.log_exception(e, current_user)
+          { mc: 'se00', msg: e.message, data: {} }
+        end
+      end
+
+      namespace :delete_standard_layer do
+        desc 'delete standard layer by id'
+        params do
+          requires :id, type: Integer, desc: 'Standard layer id'
+        end
+        route_param :id do
+          before do
+            # error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, StdLayer.find(params[:id])).destroy?
+          end
+          delete do
+            entity = Labimotion::StdLayer.find(params[:id])
+            entity.destroy
+            return { mc: 'ss00', data: {} }
+          rescue StandardError => e
+            Labimotion.log_exception(e, current_user)
+            { mc: 'se00', msg: e.message, data: [] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/labimotion/apis/vocabulary_api.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'labimotion/version'
+
+module Labimotion
+  # Generic Element API
+  class VocabularyAPI < Grape::API
+    include Grape::Kaminari
+    helpers Labimotion::ParamHelpers
+
+    resource :vocab do
+      namespace :save_vocabulary do
+        desc 'Save vocabularies'
+        params do
+          use :vocab_save
+        end
+        before do
+          # error!('Error! duplicate record', 409) if ???.present?
+        rescue ActiveRecord::RecordNotFound
+          error!('404 Not Found', 404)
+        end
+        post do
+          attributes = {
+            name: params[:name],
+            label: params[:label],
+            field_type: params[:field_type],
+            opid: 8,
+            term_id: params[:term_id],
+            source: params[:source],
+            source_id: params[:source_id],
+            layer_id: params[:layer_id],
+            field_id: params[:name],
+            identifier: SecureRandom.uuid,
+            created_by: current_user.id,
+            properties: declared(params, include_missing: false),
+          }
+          voc = Labimotion::Vocabulary.new(attributes)
+          voc.save!
+          { mc: 'ss00', data: voc }
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          { mc: 'se00', msg: e.message, data: {} }
+        end
+      end
+
+      namespace :get_all_vocabularies do
+        desc 'get all standard layers for designer'
+        get do
+          # merged_data = []
+          # Dir.glob(Rails.public_path.join('generic', 'vocabularies', '*.json')).each do |file_path|
+          #   file_content = File.read(file_path)
+          #   json_data = JSON.parse(file_content)
+          #   merged_data.concat(json_data)
+          # end
+
+          # list = Labimotion::Vocabulary.all.sort_by { |e| e.name }
+          # present list, with: Labimotion::StdLayer, root: 'klass'
+          combined_data = Labimotion::VocabularyHandler.load_all_vocabularies
+          # combined_data = Labimotion::VocabularyEntity.represent(vocabularies, serializable: true)
+          return { mc: 'ss00', data: combined_data }
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          { mc: 'se00', msg: e.message, data: [] }
+        end
+      end
+
+      namespace :field_klasses do
+        desc 'get all field klasses for admin function'
+        get do
+          # Dir.glob(Rails.public_path.join('generic', 'vocabularies', '*.json')).each do |file_path|
+          #   file_content = File.read(file_path)
+          #   json_data = JSON.parse(file_content)
+          #   merged_data.concat(json_data)
+          # end
+          vocabularies = Labimotion::VocabularyHandler.load_app_vocabularies
+          merged_data = Labimotion::FieldKlassEntity.represent(vocabularies, serializable: true)
+          # list = Labimotion::Vocabulary.all.sort_by { |e| e.name }
+          # present list, with: Labimotion::VocabularyEntity, root: 'klass'
+          merged_data
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          []
+        end
+      end
+
+      namespace :delete_vocabulary do
+        desc 'delete vocabulary by id'
+        params do
+          requires :id, type: Integer, desc: 'Vocabulary id'
+        end
+        route_param :id do
+          before do
+            # error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, Vocabulary.find(params[:id])).destroy?
+          end
+          delete do
+            entity = Labimotion::Vocabulary.find(params[:id])
+            entity.destroy
+            return { mc: 'ss00', data: {} }
+          rescue StandardError => e
+            Labimotion.log_exception(e, current_user)
+            { mc: 'se00', msg: e.message, data: [] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/labimotion/entities/dataset_entity.rb

@@ -3,7 +3,7 @@
 require 'labimotion/entities/application_entity'
 module Labimotion
   # Dataset entity
-  class DatasetEntity < ApplicationEntity
+  class DatasetEntity < PropertiesEntity
     expose :id, :dataset_klass_id, :properties, :properties_release, :element_id, :element_type, :klass_ols, :klass_label, :klass_uuid
     def klass_ols
       object&.dataset_klass&.ols_term_id
@@ -12,5 +12,6 @@ module Labimotion
     def klass_label
       object&.dataset_klass&.label
     end
+
   end
 end

data/lib/labimotion/entities/properties_entity.rb

@@ -1,61 +1,162 @@
 require 'labimotion/entities/application_entity'
 
-# Entity module
 module Labimotion
   class PropertiesEntity < Labimotion::ApplicationEntity
-
-    # TODO: Refactor this method to something more readable/understandable
     def properties
+      process_layers do |key, layer|
+        process_fields(key, layer)
+      end
+      object.properties
+    end
+
+    private
+
+    def process_layers
       (object&.properties.is_a?(Hash) && object.properties[Labimotion::Prop::LAYERS]&.keys || []).each do |key|
-        # layer = object.properties[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[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
-          sid = field.dig('value', 'el_id')
-          next unless sid.present?
-
-          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(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value').present?
-
-          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 || 'nosvg')
-        end
+        yield(key, object.properties[Labimotion::Prop::LAYERS][key])
+      end
+    end
 
-        field_sys_reactions = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::SYS_REACTION }
-        field_sys_reactions.each do |field|
-          idx = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
-          sid = field.dig('value', 'el_id')
-          next unless sid.present?
+    def process_fields(key, layer)
+      process_sample_and_molecule_fields(key, layer)
+      process_reaction_fields(key, layer)
+      process_table_fields(key, layer)
+      # process_voc_fields(key, layer)
+    end
 
-          el = Reaction.find_by(id: sid)
-          if el.blank?
-            object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_tip'] = 'ERROR'
-            object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_svg'] = ''
-          end
+    def process_sample_and_molecule_fields(key, layer)
+      select_fields(layer, [Labimotion::FieldType::DRAG_SAMPLE, Labimotion::FieldType::DRAG_MOLECULE]).each do |field, idx|
+        update_sample_or_molecule_field(key, field, idx)
+      end
+    end
+
+    def process_reaction_fields(key, layer)
+      select_fields(layer, [Labimotion::FieldType::SYS_REACTION]).each do |field, idx|
+        update_reaction_field(key, field, idx)
+      end
+    end
 
-          next unless el.present?
-          next unless object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value').present?
+    def process_table_fields(key, layer)
+      select_fields(layer, [Labimotion::FieldType::TABLE]).each do |field, idx|
+        update_table_field(key, field, idx)
+      end
+    end
 
-          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_label'] = el.short_label
-          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_tip'] = el.short_label
-          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value']['el_svg'] =  el.reaction_svg_file
-        end
+    def process_voc_fields(key, layer)
+      select_fields(layer, nil, true).each do |field, idx|
+        update_voc_field(key, field, idx)
+      end
+    end
 
-        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[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
-          next unless field['sub_values'].present? && field[Labimotion::Prop::SUBFIELDS].present?
+    def select_fields(layer, types = nil, is_voc = false)
+      fields = layer[Labimotion::Prop::FIELDS]
+      fields = fields.select { |f| types.include?(f['type']) } if types
+      fields = fields.select { |f| f['is_voc'] == true } if is_voc
+      fields.map { |f| [f, layer[Labimotion::Prop::FIELDS].index(f)] }
+    end
+
+    def update_sample_or_molecule_field(key, field, idx)
+      sid = field.dig('value', 'el_id')
+      return unless sid.present?
 
-          field_table_molecules = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_MOLECULE }
-          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] = set_table(field, field_table_molecules, Labimotion::Prop::MOLECULE) if field_table_molecules.present?
+      el = field['type'] == Labimotion::FieldType::DRAG_SAMPLE ? Sample.find_by(id: sid) : Molecule.find_by(id: sid)
+      return unless el.present? && object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value').present?
+
+      update_field_value(key, idx, {
+        'el_label' => el.short_label,
+        'el_tip' => el.short_label,
+        'el_svg' => field['type'] == Labimotion::FieldType::DRAG_SAMPLE ? el.get_svg_path : File.join('/images', 'molecules', el&.molecule_svg_file || 'nosvg')
+      })
+    end
+
+    def update_reaction_field(key, field, idx)
+      sid = field.dig('value', 'el_id')
+      return unless sid.present?
+
+      el = Reaction.find_by(id: sid)
+      if el.blank?
+        update_field_value(key, idx, { 'el_tip' => 'ERROR', 'el_svg' => '' })
+        return
+      end
 
-          field_table_samples = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_SAMPLE }
-          object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] = set_table(field, field_table_samples, Labimotion::Prop::SAMPLE) if field_table_samples.present?
+      return unless object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value').present?
+
+      update_field_value(key, idx, {
+        'el_label' => el.short_label,
+        'el_tip' => el.short_label,
+        'el_svg' => el.reaction_svg_file
+      })
+    end
+
+    def update_table_field(key, field, idx)
+      return unless field['sub_values'].present? && field[Labimotion::Prop::SUBFIELDS].present?
+
+      field_table_molecules = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_MOLECULE }
+      object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] = set_table(field, field_table_molecules, Labimotion::Prop::MOLECULE) if field_table_molecules.present?
+
+      field_table_samples = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_SAMPLE }
+      object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] = set_table(field, field_table_samples, Labimotion::Prop::SAMPLE) if field_table_samples.present?
+    end
+
+    def update_voc_field(key, field, idx)
+      root_element = get_root_element
+      case field['source']
+      when Labimotion::Prop::ELEMENT
+        update_element_voc_field(key, field, idx, root_element)
+      when Labimotion::Prop::SEGMENT
+        update_segment_voc_field(key, field, idx, root_element)
+      when Labimotion::Prop::DATASET
+        update_dataset_voc_field(key, field, idx, root_element)
+      end
+    end
+
+    def get_root_element
+      case object.class.name
+      when Labimotion::Prop::L_ELEMENT
+        object
+      when Labimotion::Prop::L_SEGMENT
+        object&.element
+      when Labimotion::Prop::L_DATASET
+        object&.element&.root_element
+      end
+    end
+
+    def update_element_voc_field(key, field, idx, root_element)
+      if field['identifier'] == 'element.name'
+        update_field_value(key, idx, root_element&.name)
+      end
+    end
+
+    def update_segment_voc_field(key, field, idx, root_element)
+      segs = root_element&.segments&.select { |ss| field['source_id'] == ss.segment_klass&.identifier }
+      return if segs.empty? || field['layer_id'].blank? || field['field_id'].blank?
+
+      seg = segs&.first
+      seg_fields = seg.properties.dig(Labimotion::Prop::LAYERS, field['layer_id'], Labimotion::Prop::FIELDS).select { |ff| ff['field'] == field['field_id'] }
+      seg_field = seg_fields&.first
+      update_field_value(key, idx, seg_field['value'])
+    end
+
+    def update_dataset_voc_field(key, field, idx, root_element)
+      dk = DatasetKlass.find_by(identifier: field["source_id"])
+      dk["ols_term_id"]
+      anas = root_element.analyses.select { |ana| ana.extended_metadata["kind"].split("|")&.first&.strip == dk["ols_term_id"] }
+      anas.each do |ana|
+        ana.children.each do |cds|
+          next unless cds.dataset.present?
+
+          ds_prop = cds.dataset.properties
+          ds_fields = ds_prop.dig(Labimotion::Prop::LAYERS, field['layer_id'], Labimotion::Prop::FIELDS).select { |ff| ff['field'] == field['field_id'] }
+          ds_field = ds_fields&.first
+          if object.properties[Labimotion::Prop::LAYERS][key].present? && ds_field['value'].present?
+            update_field_value(key, idx, ds_field['value'])
+          end
         end
       end
-      object.properties
+    end
+
+    def update_field_value(key, idx, value)
+      object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = value
     end
 
     def set_table(field, field_table_objs, obj)
@@ -69,23 +170,34 @@ module Labimotion
 
           case obj
           when Labimotion::Prop::MOLECULE
-            sub_value[col_id]['value']['el_svg'] = File.join('/images', 'molecules', find_obj.molecule_svg_file) if find_obj&.molecule_svg_file&.present?
-            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
+            update_molecule_sub_value(sub_value, col_id, find_obj)
           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
-            sub_value[col_id]['value']['el_name'] = find_obj.name
-            sub_value[col_id]['value']['el_external_label'] = find_obj.external_label
-            sub_value[col_id]['value']['el_molecular_weight'] = find_obj.decoupled ? find_obj.molecular_mass : find_obj.molecule.molecular_weight
+            update_sample_sub_value(sub_value, col_id, find_obj)
           end
         end
       end
       field
     end
 
+    def update_molecule_sub_value(sub_value, col_id, find_obj)
+      sub_value[col_id]['value'].merge!({
+        'el_svg' => File.join('/images', 'molecules', find_obj.molecule_svg_file),
+        'el_inchikey' => find_obj.inchikey,
+        'el_smiles' => find_obj.cano_smiles,
+        'el_iupac' => find_obj.iupac_name,
+        'el_molecular_weight' => find_obj.molecular_weight
+      })
+    end
+
+    def update_sample_sub_value(sub_value, col_id, find_obj)
+      sub_value[col_id]['value'].merge!({
+        'el_svg' => find_obj.get_svg_path,
+        'el_label' => find_obj.short_label,
+        'el_short_label' => find_obj.short_label,
+        'el_name' => find_obj.name,
+        'el_external_label' => find_obj.external_label,
+        'el_molecular_weight' => find_obj.decoupled ? find_obj.molecular_mass : find_obj.molecule.molecular_weight
+      })
+    end
   end
-end
+end

data/lib/labimotion/entities/segment_entity.rb

@@ -10,5 +10,6 @@ module Labimotion
       object.segment_klass.label
     end
 
+
   end
 end

data/lib/labimotion/entities/vocabulary_entity.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+#
+require 'labimotion/entities/application_entity'
+module Labimotion
+  # Dataset entity
+  class VocabularyEntity < ApplicationEntity
+    expose :id, :identifier, :name, :label, :field_type, :opid, :term_id,
+           :field_id, :properties, :source, :source_id, :layer_id
+    # expose :source do |obj|
+    #   (obj[:properties] && obj[:properties]['voc'] && obj[:properties]['voc']['source']) || ''
+    # end
+    # expose :source_id do |obj|
+    #   (obj[:properties] && obj[:properties]['voc'] && obj[:properties]['voc']['source_id']) || ''
+    # end
+    # expose :layer_id do |obj|
+    #   (obj[:properties] && obj[:properties]['voc'] && obj[:properties]['voc']['layer_id']) || ''
+    # end
+
+    expose :voc do |obj|
+      voc = (obj[:properties] && obj[:properties]['voc']) || {}
+
+      case voc['source']
+      when Labimotion::Prop::ELEMENT
+        voc['source_name'] = ElementKlass.find_by(identifier: voc['source_id'])&.label
+        # if voc['identifier'] == 'element.name'
+          # voc['source_name'] = ElementKlass.find_by(identifier: voc['source_id'])&.name
+        # end
+      when Labimotion::Prop::SEGMENT
+        voc['source_name'] = SegmentKlass.find_by(identifier: voc['source_id'])&.label
+      when Labimotion::Prop::DATASET
+        voc['source_name'] = DatasetKlass.find_by(identifier: voc['source_id'])&.label
+      end
+      voc
+    end
+    expose :ontology do |obj|
+      (obj[:properties] && obj[:properties]['ontology']) || {}
+    end
+  end
+end

data/lib/labimotion/helpers/element_helpers.rb

@@ -93,7 +93,8 @@ module Labimotion
       all_coll = Collection.get_all_collection_for_user(current_user.id)
       element.collections << all_coll
       element.save!
-      element.properties = update_sample_association(params[:properties], current_user, element)
+      _properties = update_sample_association(params[:properties], current_user, element)
+      element.properties = update_vocabularies(_properties, current_user, element)
       element.container = update_datamodel(params[:container], current_user)
       element.save!
       update_element_labels(element, params[:user_labels], current_user.id)
@@ -112,7 +113,6 @@ module Labimotion
       params.delete(:properties)
       update_element_labels(element, params[:user_labels], current_user.id)
       params.delete(:user_labels)
-
       attributes = declared(params.except(:segments), include_missing: false)
       properties['pkg'] = Labimotion::Utils.pkg(properties['pkg'])
       if element.klass_uuid != properties['klass_uuid'] || element.properties != properties || element.name != params[:name]
@@ -123,15 +123,16 @@ module Labimotion
         properties.delete('flow') unless properties['flow'].nil?
         properties.delete('flowObject') unless properties['flowObject'].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.reload
+      new_properties = update_vocabularies(element.properties, current_user, element)
+      element.update_column(:properties, new_properties)
       element
     rescue StandardError => e
       Labimotion.log_exception(e, current_user)
@@ -321,7 +322,6 @@ module Labimotion
           return { status: 'success', message: "The element: #{attributes['name']} has been created using version: #{attributes['version']}!" }
         end
       end
-
     rescue StandardError => e
       Labimotion.log_exception(e, current_user)
       return { status: 'error', message: e.message }
@@ -351,7 +351,9 @@ module Labimotion
         _att
       end
       attachments
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      attachments
     end
-
   end
 end