labimotion 1.4.1 → 2.0.0.rc6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1c30f358902beeb863766ddb2ee02b980b3cca7055f45babe20fb4211277772
-  data.tar.gz: 86e1e46884b26fbfff1a91618698ab29072940109f9bc7c3d114b48a9b93ee86
+  metadata.gz: b55a7bdf8c25fd127bd7a7bab35676d74e3f3523cb55e03516cc28d3e2df738c
+  data.tar.gz: a28bad0092a10adc3befb26c3803d5f969d40bf9e387a7015890c2f81cd3089e
 SHA512:
-  metadata.gz: 41655a864b15b848116b370964ae6a05c707512d6ba80987cdec1f392d3fb647476fcf119612f116a2923c4992e32b00127371ac8a77d6e7de6cf1dc94773dbd
-  data.tar.gz: 8308707ad72ac2ebd38c725bc1336151712b5900fa4f35429674ee54f26cbe6fcc7ed43ef71777b6dd069701411540c776a7f183b183d147c1a3658a124e12a7
+  metadata.gz: 94b3f84c3b2588b08f19c66bafdd17fb9eef3674040bd3dc0683132a4b5709c11f643e81afda2109741da24e4a38c6b407c4eff279c00c9292ef0942611c4ec8
+  data.tar.gz: 19082b803643920e698b9f14c1ce89b68aac5121a5adeab473d86c16c7129ba1d9e024e1bcec83b7c802ed79409183e1129967881295b66c363912652d563191

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,25 @@
+# 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!('standard_layers')
+          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,87 @@
+# frozen_string_literal: true
+
+require 'labimotion/version'
+
+module Labimotion
+  # Generic Element API
+  class StandardLayerAPI < Grape::API
+    include Grape::Kaminari
+    helpers Labimotion::ParamHelpers
+    helpers Labimotion::GenericHelpers
+
+    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 }
+          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'
+        route_param :id do
+          get do
+            authenticate_admin!('standard_layers')
+            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
+          authenticate_admin!('standard_layers')
+          cur_layer = Labimotion::StdLayer.find_by(name: params[:key])
+          error!('Error! duplicate name', 409) if cur_layer.present?
+        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
+            authenticate_admin!('standard_layers')
+          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,93 @@
+# frozen_string_literal: true
+
+require 'labimotion/version'
+
+module Labimotion
+  # Generic Element API
+  class VocabularyAPI < Grape::API
+    include Grape::Kaminari
+    helpers Labimotion::ParamHelpers
+    helpers Labimotion::GenericHelpers
+
+    resource :vocab do
+      namespace :save_vocabulary do
+        desc 'Save vocabularies'
+        params do
+          use :vocab_save
+        end
+        before do
+          authenticate_admin!('vocabularies')
+        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: params[:source_id],
+            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
+          authenticate_admin!('vocabularies')
+          combined_data = Labimotion::VocabularyHandler.load_all_vocabularies
+          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
+          authenticate_admin!('vocabularies')
+          vocabularies = Labimotion::VocabularyHandler.load_app_vocabularies
+          merged_data = Labimotion::FieldKlassEntity.represent(vocabularies, serializable: true)
+          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
+            authenticate_admin!('vocabularies')
+          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/constants.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Labimotion
+  module Constants
+    module DateTime
+      DATE_FORMAT = '%Y-%m-%d'
+      DATETIME_FORMAT = '%Y-%m-%d %H:%M:%S %Z'
+      TIME_FORMAT = '%H:%M:%S %Z'
+      TIME_ZONE = 'UTC'
+    end
+
+    module File
+      ENCODING = 'UTF-8'
+    end
+
+    module Mapper
+      NMR_CONFIG = ::File.join(__dir__, 'libs', 'data', 'mapper', 'Source.json').freeze
+      WIKI_CONFIG = ::File.join(__dir__, 'libs', 'data', 'mapper', 'Chemwiki.json').freeze
+    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

data/lib/labimotion/entities/element_entity.rb

@@ -20,6 +20,7 @@ module Labimotion
       expose! :thumb_svg
       expose! :type
       expose! :uuid
+      expose! :user_labels
     end
 
     with_options(anonymize_below: 10) do

data/lib/labimotion/entities/properties_entity.rb

@@ -1,91 +1,264 @@
 require 'labimotion/entities/application_entity'
 
-# Entity module
 module Labimotion
   class PropertiesEntity < Labimotion::ApplicationEntity
-
-    # TODO: Refactor this method to something more readable/understandable
     def properties
-      (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
+      process_layers do |key, layer|
+        process_fields(key, layer)
+      end
+      object.properties
+    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?
+    private
 
-          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_layers
+      (object&.properties.is_a?(Hash) && (object.properties[Labimotion::Prop::LAYERS]&.keys || [])).each do |key|
+        yield(key, object.properties[Labimotion::Prop::LAYERS][key])
+      end
+    end
 
-          next unless el.present?
-          next unless object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value').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
 
-          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_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
+
+    def process_table_fields(key, layer)
+      select_fields(layer, [Labimotion::FieldType::TABLE]).each do |field, idx|
+        update_table_field(key, field, idx)
+      end
+    end
+
+    def process_voc_fields(key, layer)
+      select_fields(layer, nil, true).each do |field, idx|
+        update_voc_field(key, field, idx)
+      end
+    end
+
+    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?
+
+      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?
+
+      label = field['type'] == Labimotion::FieldType::DRAG_SAMPLE ? el&.short_label : el.iupac_name
+      update_field_value(key, idx, {
+                           'el_label' => label,
+                           'el_tip' => label,
+                           'el_svg' => if field['type'] == Labimotion::FieldType::DRAG_SAMPLE
+                                         el&.get_svg_path
+                                       else
+                                         File.join('/images',
+                                                   'molecules', el&.molecule_svg_file || 'nosvg')
+                                       end
+                         })
+    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
+
+      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 do |ss|
+        ss['type'] == Labimotion::FieldType::DRAG_MOLECULE
+      end
+      if field_table_molecules.present?
+        object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] =
+          set_table(field, field_table_molecules, Labimotion::Prop::MOLECULE)
+      end
+
+      field_table_samples = field[Labimotion::Prop::SUBFIELDS].select do |ss|
+        ss['type'] == Labimotion::FieldType::DRAG_SAMPLE
+      end
+      return unless field_table_samples.present?
+
+      object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] =
+        set_table(field, field_table_samples, Labimotion::Prop::SAMPLE)
+    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
 
-        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 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
 
-          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?
+    def update_element_voc_field(key, field, idx, root_element)
+      return unless field['identifier'] == 'element.name'
+
+      update_field_value(key, idx, root_element&.name)
+    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?
+    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 do |ff|
+        ff['field'] == field['field_id']
+      end
+      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 do |ana|
+        ana.extended_metadata['kind'].split('|')&.first&.strip == dk['ols_term_id']
+      end
+      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 do |ff|
+            ff['field'] == field['field_id']
+          end
+          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, act = 'merge')
+      field_path = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]
+      original_value = field_path['value']
+
+      field_path['value'] = merge_values(original_value, value, act)
+    end
+
+    def merge_by_type(original_value, new_value)
+      if original_value.is_a?(Hash)
+        merge_hash_values(original_value, new_value)
+      # elsif original_value.is_a?(Array)
+      #   merge_array_values(original_value, new_value)
+      else
+        new_value
+      end
+    end
+
+    def merge_values(original_value, new_value, act)
+      return new_value if act == 'overwrite'
+      return new_value if original_value.blank?
+      return original_value if new_value.blank?
+
+      merge_by_type(original_value, new_value)
     end
 
     def set_table(field, field_table_objs, obj)
       col_ids = field_table_objs.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?
+          unless sub_value[col_id].present? && sub_value[col_id]['value'].present? && sub_value[col_id]['value']['el_id'].present?
+            next
+          end
 
           find_obj = obj.constantize.find_by(id: sub_value[col_id]['value']['el_id'])
           next if find_obj.blank?
 
           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
+
+    def merge_hash_values(original, new_value)
+      return original unless new_value.is_a?(Hash)
+
+      original.merge(new_value)
+    end
+
+    def merge_array_values(original, new_value)
+      return original unless new_value.respond_to?(:to_a)
+
+      (original + new_value.to_a).uniq
+    end
   end
 end

data/lib/labimotion/entities/segment_entity.rb

@@ -9,6 +9,5 @@ module Labimotion
     def klass_label
       object.segment_klass.label
     end
-
   end
 end

data/lib/labimotion/entities/vocabulary_entity.rb

@@ -0,0 +1,28 @@
+# 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 :voc do |obj|
+      voc = (obj[:properties] && obj[:properties]['voc']) || {}
+
+      case voc['source']
+      when Labimotion::Prop::ELEMENT
+        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