labimotion 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c1fa1527f921643836476d930d66fedc973e06e2a6300d9e100e2852fc96168
-  data.tar.gz: 4ccc2fe165c170aa98fba5db9d63c576ed997e9650e54da439b1b295da65c816
+  metadata.gz: fb9257b355d7ffd4825004ffd9ba25b4bc91cd4779b1bc84878e44d4d980d637
+  data.tar.gz: eb9ab9cf1eca01cf9e3eff8ac1fad6de9ea21c39cc71f37f2f6c9726a5984a5d
 SHA512:
-  metadata.gz: 39915628df304676e86ad4e601d6776e994eb5007cc2f857c48b64498c24dba596d3ae1a46136b1d9c909dc3620724c10f0605682ba34224430c5405324d9076
-  data.tar.gz: fae1a472384cd8ba2c7e93c647399add301ed35e4404038382f451c6b2f2c7644331004c67cba91e76872e844b334fb8041e4a1dbf682dc6644010d9fd7630fe
+  metadata.gz: 713086e4492a67109dabe07f475fd7561374319bcff1ef97e71998c5c760b5e3f4ccecd7517aa5014441f2e0b74fb7267825c1b5365d4ba398694b25e225c05a
+  data.tar.gz: ae6e23e4702ee8d56e9bcd39b0b5a34706b4a5c257a2c35a4d1223da76ea175cdd89ef901a4d9ab547a6c40a9e629c376baa345cefaa67609ab3ec10d25ad13e

data/lib/labimotion/apis/labimotion_api.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # app/api/labimotion/central_api.rb
 module Labimotion
   class LabimotionAPI < Grape::API
@@ -10,4 +12,4 @@ module Labimotion
     mount Labimotion::StandardLayerAPI
     mount Labimotion::VocabularyAPI
   end
-end
+end

data/lib/labimotion/apis/labimotion_hub_api.rb

@@ -11,24 +11,24 @@ module Labimotion
 
     namespace :labimotion_hub do
       namespace :list do
-        desc "get active generic templates"
+        desc 'get active generic templates'
         params do
-          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+          requires :klass, type: String, desc: 'Klass', values: Labimotion::Constants::Klass::ALL
           optional :with_props, type: Boolean, desc: 'With Properties', default: false
         end
         get do
           list = "Labimotion::#{params[:klass]}".constantize.where(is_active: true).where.not(released_at: nil)
-          list = list.where(is_generic: true) if params[:klass] == 'ElementKlass'
-          entities = Labimotion::GenericPublicEntity.represent(list, displayed: params[:with_props], root: 'list')
+          list = list.where(is_generic: true) if params[:klass] == Labimotion::Constants::Klass::ELEMENT
+          Labimotion::GenericPublicEntity.represent(list, displayed: params[:with_props], root: 'list')
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)
           []
         end
       end
       namespace :fetch do
-        desc "get active generic templates"
+        desc 'get active generic templates'
         params do
-          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+          requires :klass, type: String, desc: 'Klass', values: Labimotion::Constants::Klass::ALL
           requires :origin, type: String, desc: 'origin'
           requires :identifier, type: String, desc: 'Identifier'
         end
@@ -43,13 +43,16 @@ module Labimotion
       end
 
       namespace :element_klasses_name do
-        desc "get klasses"
+        desc 'get klasses'
         params do
-          optional :generic_only, type: Boolean, desc: "list generic element only"
+          optional :generic_only, type: Boolean, desc: 'list generic element only'
         end
         get do
-          list = Labimotion::ElementKlass.where(is_active: true) if params[:generic_only].present? && params[:generic_only] == true
-          list = Labimotion::ElementKlass.where(is_active: true) unless params[:generic_only].present? && params[:generic_only] == true
+          if params[:generic_only].present? && params[:generic_only] == true
+            list = Labimotion::ElementKlass.where(is_active: true, is_generic: true)
+          else
+            list = Labimotion::ElementKlass.where(is_active: true)
+          end
           list.pluck(:name)
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)
@@ -57,6 +60,76 @@ module Labimotion
         end
       end
 
+      namespace :submit do
+        desc 'submit a template'
+        params do
+          requires :klass, type: String, desc: 'klass of the template',
+                           values: Labimotion::Constants::Klass::ALL
+          requires :id, type: Integer, desc: 'template revision id'
+          requires :contact_email, type: String, desc: 'email of the submitter', regexp: URI::MailTo::EMAIL_REGEXP
+          requires :application, type: String, desc: 'application for the template'
+          requires :message, type: String, desc: 'message of the submission'
+        end
+        post do
+          klass = params[:klass]
+          template = "Labimotion::#{klass}esRevision".constantize.find(params[:id])
+          klass_data = "Labimotion::#{klass}Entity".constantize.represent(template.klass, displayed_in_list: true)
+          metadata = {
+            klass: {
+              klass: klass,
+              data: klass_data
+            },
+            submission: {
+              last_name: current_user.last_name,
+              first_name: current_user.first_name,
+              email: current_user.email,
+              id: current_user.id,
+              contact_email: params[:contact_email],
+              application: params[:application],
+              message: params[:message]
+            }
+          }
+
+          # Submit the main template
+          result = Labimotion::TemplateHub.send_to_central_hub(klass, template.properties_release, metadata,
+                                                               request.headers['Origin'])
+
+          # Increment submitted counter if submission was successful
+          template.increment_submitted! if result[:mc] == 'ss00'
+
+          # For SegmentKlass, also submit the associated ElementKlass
+          if klass == Labimotion::Constants::Klass::SEGMENT && result[:mc] == 'ss00'
+            element_klass = template.klass.element_klass
+            element_klass_data = Labimotion::ElementKlassEntity.represent(element_klass, displayed_in_list: true)
+            element_metadata = {
+              klass: {
+                klass: Labimotion::Constants::Klass::ELEMENT,
+                data: element_klass_data
+              },
+              submission: metadata[:submission].merge(
+                associated_submission_id: result[:data][:id]
+              )
+            }
+
+            element_result = Labimotion::TemplateHub.send_to_central_hub(Labimotion::Constants::Klass::ELEMENT,
+                                                                         element_klass.properties_release,
+                                                                         element_metadata, request.headers['Origin'])
+
+            # Increment the ElementKlass revision counter if submission was successful
+            if element_result[:mc] == 'ss00'
+              # Find the revision that matches the ElementKlass UUID
+              element_revision = Labimotion::ElementKlassesRevision.find_by(uuid: element_klass.uuid)
+              element_revision&.increment_submitted!
+            end
+          end
+
+          # Only return the main result; TODO: handle element_result as well
+          result
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          { mc: 'se00', msg: e.message, data: [] }
+        end
+      end
     end
   end
 end

data/lib/labimotion/apis/standard_api.rb

@@ -13,7 +13,8 @@ module Labimotion
           use :create_std_layer_params
         end
         post do
-          authenticate_admin!('standard_layers')
+          # authenticate_admin!('elements')
+          # create_element_klass(current_user, params)
           create_std_layer(current_user, params)
           status 201
         rescue ActiveRecord::RecordInvalid => e

data/lib/labimotion/apis/standard_layer_api.rb

@@ -7,13 +7,14 @@ module Labimotion
   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 }
+          # 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)
@@ -23,9 +24,17 @@ module Labimotion
 
       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
-            authenticate_admin!('standard_layers')
             entity = Labimotion::StdLayer.find(params[:id])
             return { mc: 'ss00', data: entity }
           rescue StandardError => e
@@ -41,9 +50,13 @@ module Labimotion
           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?
+          # @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 = {
@@ -70,7 +83,7 @@ module Labimotion
         end
         route_param :id do
           before do
-            authenticate_admin!('standard_layers')
+            # error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, StdLayer.find(params[:id])).destroy?
           end
           delete do
             entity = Labimotion::StdLayer.find(params[:id])

data/lib/labimotion/apis/vocabulary_api.rb

@@ -7,7 +7,6 @@ module Labimotion
   class VocabularyAPI < Grape::API
     include Grape::Kaminari
     helpers Labimotion::ParamHelpers
-    helpers Labimotion::GenericHelpers
 
     resource :vocab do
       namespace :save_vocabulary do
@@ -16,7 +15,7 @@ module Labimotion
           use :vocab_save
         end
         before do
-          authenticate_admin!('vocabularies')
+          # error!('Error! duplicate record', 409) if ???.present?
         rescue ActiveRecord::RecordNotFound
           error!('404 Not Found', 404)
         end
@@ -31,7 +30,7 @@ module Labimotion
             source_id: params[:source_id],
             layer_id: params[:layer_id],
             field_id: params[:name],
-            identifier: SecureRandom.uuid,
+            identifier: params[:source_id],
             created_by: current_user.id,
             properties: declared(params, include_missing: false),
           }
@@ -47,8 +46,17 @@ module Labimotion
       namespace :get_all_vocabularies do
         desc 'get all standard layers for designer'
         get do
-          authenticate_admin!('vocabularies')
+          # 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)
@@ -59,9 +67,15 @@ module Labimotion
       namespace :field_klasses do
         desc 'get all field klasses for admin function'
         get do
-          authenticate_admin!('vocabularies')
+          # 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)
@@ -76,7 +90,7 @@ module Labimotion
         end
         route_param :id do
           before do
-            authenticate_admin!('vocabularies')
+            # error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, Vocabulary.find(params[:id])).destroy?
           end
           delete do
             entity = Labimotion::Vocabulary.find(params[:id])

data/lib/labimotion/constants.rb

@@ -21,5 +21,12 @@ module Labimotion
       NMR_CONFIG = ::File.join(__dir__, 'libs', 'data', 'mapper', 'Source.json').freeze
       WIKI_CONFIG = ::File.join(__dir__, 'libs', 'data', 'mapper', 'Chemwiki.json').freeze
     end
+
+    module Klass
+      ELEMENT = 'ElementKlass'
+      SEGMENT = 'SegmentKlass'
+      DATASET = 'DatasetKlass'
+      ALL = [ELEMENT, SEGMENT, DATASET].freeze
+    end
   end
 end

data/lib/labimotion/entities/dataset_entity.rb

@@ -12,5 +12,6 @@ module Labimotion
     def klass_label
       object&.dataset_klass&.label
     end
+
   end
 end

data/lib/labimotion/entities/element_entity.rb

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

data/lib/labimotion/entities/klass_revision_entity.rb

@@ -1,15 +1,12 @@
 # frozen_string_literal: true
 
 module Labimotion
-  # KlassRevisionEntity
-  class KlassRevisionEntity < ApplicationEntity
-    expose :id, :uuid, :properties_release, :version, :released_at
+  class KlassRevisionEntity < Labimotion::ApplicationEntity
+    expose :id, :uuid, :version, :released_at, :klass_id, :submitted
+    expose :properties_release, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
 
-    expose :klass_id do |object|
-      klass_id = object.element_klass_id if object.respond_to? :element_klass_id
-      klass_id = object.segment_klass_id if object.respond_to? :segment_klass_id
-      klass_id = object.dataset_klass_id if object.respond_to? :dataset_klass_id
-      klass_id
+    def klass_id
+      object.klass&.id
     end
 
     def released_at
@@ -17,4 +14,3 @@ module Labimotion
     end
   end
 end
-

data/lib/labimotion/entities/properties_entity.rb

@@ -12,7 +12,7 @@ module Labimotion
     private
 
     def process_layers
-      (object&.properties.is_a?(Hash) && (object.properties[Labimotion::Prop::LAYERS]&.keys || [])).each do |key|
+      (object&.properties.is_a?(Hash) && object.properties[Labimotion::Prop::LAYERS]&.keys || []).each do |key|
         yield(key, object.properties[Labimotion::Prop::LAYERS][key])
       end
     end
@@ -25,8 +25,7 @@ module Labimotion
     end
 
     def process_sample_and_molecule_fields(key, layer)
-      select_fields(layer,
-                    [Labimotion::FieldType::DRAG_SAMPLE, Labimotion::FieldType::DRAG_MOLECULE]).each do |field, idx|
+      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
@@ -61,20 +60,13 @@ module Labimotion
       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?
+      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
-                         })
+        '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)
@@ -87,34 +79,23 @@ module Labimotion
         return
       end
 
-      return unless object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx,
-                                          'value').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
-                         })
+        '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?
+      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?
 
-      object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] =
-        set_table(field, field_table_samples, Labimotion::Prop::SAMPLE)
+      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)
@@ -141,9 +122,9 @@ module Labimotion
     end
 
     def update_element_voc_field(key, field, idx, root_element)
-      return unless field['identifier'] == 'element.name'
-
-      update_field_value(key, idx, root_element&.name)
+      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)
@@ -151,28 +132,21 @@ module Labimotion
       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_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 do |ana|
-        ana.extended_metadata['kind'].split('|')&.first&.strip == dk['ols_term_id']
-      end
+      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 do |ff|
-            ff['field'] == field['field_id']
-          end
+          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'])
@@ -181,38 +155,15 @@ module Labimotion
       end
     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)
+    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)
       col_ids = field_table_objs.map { |x| x.values[0] }
       col_ids.each do |col_id|
         field['sub_values'].each do |sub_value|
-          unless sub_value[col_id].present? && sub_value[col_id]['value'].present? && sub_value[col_id]['value']['el_id'].present?
-            next
-          end
+          next unless sub_value[col_id].present? && sub_value[col_id]['value'].present? && sub_value[col_id]['value']['el_id'].present?
 
           find_obj = obj.constantize.find_by(id: sub_value[col_id]['value']['el_id'])
           next if find_obj.blank?
@@ -230,35 +181,23 @@ module Labimotion
 
     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
-                                        })
+        '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
+        '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

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

data/lib/labimotion/entities/vocabulary_entity.rb

@@ -6,15 +6,24 @@ module Labimotion
   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'
+        if voc['identifier'] == 'element.name'
           # voc['source_name'] = ElementKlass.find_by(identifier: voc['source_id'])&.name
-        # end
+        end
       when Labimotion::Prop::SEGMENT
         voc['source_name'] = SegmentKlass.find_by(identifier: voc['source_id'])&.label
       when Labimotion::Prop::DATASET

data/lib/labimotion/helpers/element_helpers.rb

@@ -127,12 +127,11 @@ module Labimotion
         attributes['properties']['uuid'] = uuid
         attributes['uuid'] = uuid
         attributes['klass_uuid'] = properties['klass_uuid']
-        element.update_columns(attributes)
+        element.update(attributes)
       end
       element.save_segments(segments: params[:segments], current_user_id: current_user.id)
       element.reload
       element.properties = update_vocabularies(element.properties, current_user, element)
-      ## element.user_for_revision = current_user
       element.save!
       element
     rescue StandardError => e

data/lib/labimotion/helpers/generic_helpers.rb

@@ -9,12 +9,7 @@ module Labimotion
     extend Grape::API::Helpers
 
     def authenticate_admin!(type)
-      unauthorized = -> { error!('401 Unauthorized', 401) }
-      if %w[standard_layers vocabularies].include?(type)
-        unauthorized.call unless current_user.generic_admin.values_at('elements', 'segments', 'datasets').any?
-      else
-        unauthorized.call unless current_user.generic_admin[type]
-      end
+      error!('401 Unauthorized', 401) unless current_user.generic_admin[type]
     end
 
     def fetch_klass(name, id)