labimotion 2.0.3 → 2.1.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27be8adb524b2f909b6b63a93395c828b5c95af139fc7babc6e0d80a014f7fd1
-  data.tar.gz: 7bfbbd295d0c9147e52eef054e96575a312edefdc4b999b8a5adda3e2b3afb8c
+  metadata.gz: dc6bf6015a4c970c7f2bd3e3d6e1a2dfb334e6acc4c53f255c5ef7cb912b6b1e
+  data.tar.gz: c8d7fda79cb1e3967a884b7ebd53db0f08eb90777ec0f78e58cabada98038f82
 SHA512:
-  metadata.gz: 5ab9fcec0f65c23cfb02df0248b0ae2c83311ef92d56051d5eb577c60d43dd34071f4a51040565ce18516fc3560882fd041a9f7ea88ab815ffbb797828aa48f8
-  data.tar.gz: b90813c81ba3d4ba60b3b60a6e62ac8af96b53caf20efc61a57098725366d256f7c54a252b6a802fac522a92e7eb524e960030fbb07f6fbb4943cbd0bcb508ad
+  metadata.gz: 0dc6b6c5242a5480c52535ab0dba78593ed66258ba9d509c8d10674dcddd50a683a319331753b098112889faa6c5199df2dab26a17e16990944227ff914a85ff
+  data.tar.gz: e78481dec58ed4a2a3e50d968fd39561ce0a2e25aba773db3f1f97b79cdc58c2737c3ec354456ceb1eb3fcae8a953ad51228f631720f9dc31dbabd4b794856d5

data/lib/labimotion/apis/generic_dataset_api.rb

@@ -11,19 +11,36 @@ module Labimotion
       namespace :klasses do
         desc 'get dataset klasses'
         get do
-          list = klass_list(true)
+          list = klass_list(true, false)
           present list.sort_by(&:place), with: Labimotion::DatasetKlassEntity, root: 'klass'
         end
       end
 
+      namespace :list_klass do
+        desc 'list Generic Dataset Klass'
+        params do
+          optional :is_active, type: Boolean, desc: 'Active or Inactive Dataset'
+          optional :displayed_in_list, type: Boolean, desc: 'Display in list format', default: true
+        end
+        get do
+          list = klass_list(params[:is_active], params[:displayed_in_list])
+          serialized_data = Labimotion::DatasetKlassEntity.represent(list, displayed_in_list: params[:displayed_in_list])
+          { mc: 'ss00', data: serialized_data }
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          { mc: 'se00', msg: e.message, data: [] }
+        end
+      end
+
+      # Deprecated: This namespace is no longer used, but kept for backward compatibility. It is replaced by `list_klass`.
       namespace :list_dataset_klass do
         desc 'list Generic Dataset Klass'
         params do
           optional :is_active, type: Boolean, desc: 'Active or Inactive Dataset'
         end
         get do
-          list = klass_list(params[:is_active])
-          present list, with: Labimotion::DatasetKlassEntity, root: 'klass'
+          list = klass_list(params[:is_active], false)
+          present list, with: Labimotion::DatasetKlassEntity, root: 'klass', displayed_in_list: false
         end
       end
 

data/lib/labimotion/apis/generic_element_api.rb

@@ -221,6 +221,26 @@ module Labimotion
         end
       end
 
+      namespace :list_element_klass do
+        desc 'list Generic Element Klass'
+        params do
+          optional :is_generic, type: Boolean, desc: 'Is Generic or Non-Generic Element'
+          optional :is_active, type: Boolean, desc: 'Active or Inactive Dataset'
+          optional :displayed_in_list, type: Boolean, desc: 'Display in list format', default: true
+        end
+        get do
+          scope = params[:displayed_in_list] ? Labimotion::ElementKlass.for_list_display : Labimotion::ElementKlass.all
+          scope = scope.where(is_generic: params[:is_generic]) if params.key?(:is_generic)
+
+          list = scope.sort_by(&:place)
+          present list, with: Labimotion::ElementKlassEntity, root: 'klass', displayed_in_list: params[:displayed_in_list]
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          raise e
+        end
+      end
+
+      # Deprecated: This namespace is no longer used, but kept for backward compatibility.
       namespace :klasses_all do
         desc 'get all klasses for admin function'
         get do
@@ -266,7 +286,7 @@ module Labimotion
         end
         after_validation do
           authenticate_admin!(params[:klass].gsub(/(Klass)/, 's').downcase)
-          @klz = fetch_klass(params[:klass], params[:id])
+          fetch_klass(params[:klass], params[:id])
         end
         post do
           deactivate_klass(params)
@@ -301,7 +321,7 @@ module Labimotion
         end
         after_validation do
           authenticate_admin!(params[:klass].gsub(/(Klass)/, 's').downcase)
-          @klz = fetch_klass(params[:klass], params[:id])
+          fetch_klass(params[:klass], params[:id])
         end
         post do
           update_template(params, current_user)

data/lib/labimotion/apis/generic_klass_api.rb

@@ -6,6 +6,7 @@ require 'labimotion/libs/export_element'
 module Labimotion
   # Generic Element API
   class GenericKlassAPI < Grape::API
+    helpers Labimotion::GenericHelpers
 
     resource :generic_klass do
       namespace :download_klass do
@@ -30,6 +31,44 @@ module Labimotion
         end
       end
 
+      namespace :de_activate do
+        desc 'activate or deactivate Generic Klass'
+        params do
+          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+          requires :id, type: Integer, desc: 'Klass ID'
+          requires :is_active, type: Boolean, desc: 'Active or Inactive Klass'
+        end
+        after_validation do
+          authenticate_admin!(params[:klass].gsub(/(Klass)/, 's').downcase)
+          fetch_klass(params[:klass], params[:id])
+        end
+        post do
+          updated_klass = deactivate_klass(params)
+          entity_class = "Labimotion::#{params[:klass]}Entity".constantize
+          serialized_data = entity_class.represent(updated_klass)
+          { mc: 'ss00', data: serialized_data }
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          { mc: 'se00', msg: e.message, data: {} }
+        end
+      end
+
+      namespace :fetch do
+        desc 'fetch Generic Klass by id'
+        params do
+          requires :id, type: Integer, desc: 'Klass ID'
+          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+        end
+        get do
+          klass_obj = fetch_klass(params[:klass], params[:id])
+          entity_class = "Labimotion::#{params[:klass]}Entity".constantize
+          serialized_data = entity_class.represent(klass_obj)
+          { mc: 'ss00', data: serialized_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/labimotion_api.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # app/api/labimotion/central_api.rb
 module Labimotion
   class LabimotionAPI < Grape::API
@@ -12,4 +10,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: Labimotion::Constants::Klass::ALL
+          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
           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] == Labimotion::Constants::Klass::ELEMENT
-          Labimotion::GenericPublicEntity.represent(list, displayed: params[:with_props], root: 'list')
+          list = list.where(is_generic: true) if params[:klass] == 'ElementKlass'
+          entities = 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: Labimotion::Constants::Klass::ALL
+          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
           requires :origin, type: String, desc: 'origin'
           requires :identifier, type: String, desc: 'Identifier'
         end
@@ -43,16 +43,13 @@ 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
-          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 = 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
           list.pluck(:name)
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)
@@ -60,76 +57,6 @@ 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/segment_api.rb

@@ -12,19 +12,21 @@ module Labimotion
           optional :element, type: String, desc: "Klass Element, e.g. Sample, Reaction, Mof,..."
         end
         get do
-          list = klass_list(params[:element], true)
+          list = klass_list(params[:element], true, false)
           present list, with: Labimotion::SegmentKlassEntity, root: 'klass'
         end
       end
 
+      # TODO: params[:displayed_in_list] will be used in the future to control the display format, set 'false' for now.
       namespace :list_segment_klass do
         desc 'list Generic Segment Klass'
         params do
           optional :is_active, type: Boolean, desc: 'Active or Inactive Segment'
+          optional :displayed_in_list, type: Boolean, desc: 'Display in list format', default: false
         end
         get do
-          list = klass_list(nil, params[:is_active])
-          present list, with: Labimotion::SegmentKlassEntity, root: 'klass'
+          list = klass_list(nil, params[:is_active], false)
+          present list, with: Labimotion::SegmentKlassEntity, root: 'klass', displayed_in_list: false
         end
       end
 

data/lib/labimotion/constants.rb

@@ -21,12 +21,5 @@ 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/application_entity.rb

@@ -1,88 +1,15 @@
 # frozen_string_literal: true
-#
+
 module Labimotion
   ## ApplicationEntity
-  class ApplicationEntity < Grape::Entity
-    CUSTOM_ENTITY_OPTIONS = %i[anonymize_below anonymize_with].freeze
+  # This class serves as the base entity for the Labimotion module,
+  # inheriting from the core ApplicationEntity and providing custom formatting.
+  class ApplicationEntity < ::Entities::ApplicationEntity
+    # Common condition for fields that should not be displayed in list views
+    DISPLAYED_IN_LIST_CONDITION = { unless: :displayed_in_list }.freeze
 
     format_with(:eln_timestamp) do |datetime|
-      datetime.present? ? datetime&.strftime('%Y-%m-%d %H:%M:%S %Z')  : nil
-    end
-
-    def self.expose!(*args)
-      fields = args.first
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      options = merge_options(options) # merges additional params set in #with_options
-      expose_fields_with_anonymization!(fields, options)
-    end
-
-    # rubocop:disable Metrics/MethodLength
-    def self.expose_fields_with_anonymization!(fields, options)
-      anonymize_below = options[:anonymize_below] || 0
-      anonymize_with = options.key?(:anonymize_with) ? options[:anonymize_with] : '***'
-
-      Array(fields).each do |field|
-        expose(field, options) do |represented_object, _options|
-          if detail_levels[represented_object.class] < anonymize_below
-            anonymize_with
-          elsif respond_to?(field, true) # Entity has a method with the same name
-            send(field)
-          elsif represented_object.respond_to?(field)
-            represented_object.public_send(field)
-          else
-            represented_object[field] # works both for AR and Hash objects
-          end
-        end
-      end
-    end
-    private_class_method :expose_fields_with_anonymization!
-    # rubocop:enable Metrics/MethodLength
-
-    def self.expose_timestamps(timestamp_fields: %i[created_at updated_at], **additional_args)
-      timestamp_fields.each do |field|
-        expose field, format_with: :eln_timestamp, **additional_args
-      end
-    end
-
-    # overridden method from Grape::Entity to support our custom anonymization options
-    # https://github.com/ruby-grape/grape-entity/blob/v0.7.1/lib/grape_entity/entity.rb#L565
-    def self.valid_options(options)
-      options.each_key do |key|
-        next if OPTIONS.include?(key) || CUSTOM_ENTITY_OPTIONS.include?(key)
-
-        raise ArgumentError, "#{key.inspect} is not a valid option."
-      end
-
-      options[:using] = options.delete(:with) if options.key?(:with)
-      options
-    end
-    private_class_method :valid_options
-
-    private
-
-    def displayed_in_list?
-      options[:displayed_in_list] == true
-    end
-
-    def current_user
-      unless options[:current_user]
-        raise MissingCurrentUserError, "#{self.class} requires a current user to work properly"
-      end
-
-      options[:current_user]
-    end
-
-    def detail_levels
-      maximal_default_levels = Hash.new(10) # every requested detail level will be returned as 10
-      minimal_default_levels = Hash.new(0) # every requested detail level will be returned as 0
-      return maximal_default_levels if !options.key?(:detail_levels) || options[:detail_levels].empty?
-
-      # When explicitly configured detail levels are available, we want to return only those and all other
-      # requests (by using `detail_levels[SomeUnconfiguredModel]`) should return the minimum detail level
-      minimal_default_levels.merge(options[:detail_levels])
-    end
-
-    class MissingCurrentUserError < StandardError
+      datetime.present? ? datetime.strftime('%Y-%m-%d %H:%M:%S %Z') : nil
     end
   end
 end

data/lib/labimotion/entities/dataset_entity.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
-#
+
 require 'labimotion/entities/application_entity'
+require 'labimotion/entities/properties_entity'
 module Labimotion
   # Dataset entity
-  class DatasetEntity < PropertiesEntity
-    expose :id, :dataset_klass_id, :properties, :properties_release, :element_id, :element_type, :klass_ols, :klass_label, :klass_uuid
+  class DatasetEntity < Labimotion::PropertiesEntity
+    expose :id, :dataset_klass_id, :element_id, :element_type
+    expose :klass_ols, :klass_label, :klass_uuid
+    expose :properties, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
+    expose :properties_release, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
+
     def klass_ols
       object&.dataset_klass&.ols_term_id
     end

data/lib/labimotion/entities/dataset_klass_entity.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 require 'labimotion/entities/generic_klass_entity'
 module Labimotion
-  class DatasetKlassEntity < GenericKlassEntity
+  class DatasetKlassEntity < Labimotion::GenericKlassEntity
     expose(
-      :ols_term_id,
+      :ols_term_id
     )
   end
 end

data/lib/labimotion/entities/element_entity.rb

@@ -3,7 +3,7 @@
 require 'labimotion/entities/properties_entity'
 ## TODO: Refactor labimotion to use the same entities as chemotion
 module Labimotion
-  class ElementEntity < PropertiesEntity
+  class ElementEntity < Labimotion::PropertiesEntity
     with_options(anonymize_below: 0) do
       expose! :can_copy,        unless: :displayed_in_list
       expose! :can_publish,     unless: :displayed_in_list

data/lib/labimotion/entities/element_klass_entity.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
-#
+
 require 'labimotion/entities/generic_klass_entity'
 
 module Labimotion
   # ElementKlassEntity
-  class ElementKlassEntity < GenericKlassEntity
+  class ElementKlassEntity < Labimotion::GenericKlassEntity
     expose :name, :icon_name, :klass_prefix, :is_generic
   end
 end

data/lib/labimotion/entities/element_revision_entity.rb

@@ -3,7 +3,7 @@
 require 'labimotion/entities/application_entity'
 module Labimotion
   # ElementRevisionEntity
-  class ElementRevisionEntity < ApplicationEntity
+  class ElementRevisionEntity < Labimotion::ApplicationEntity
     expose :id, :element_id, :uuid, :name, :klass_uuid, :properties, :created_at
     def created_at
       object.created_at.strftime('%d.%m.%Y, %H:%M')

data/lib/labimotion/entities/eln_element_entity.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
-#
+
 require 'labimotion/entities/application_entity'
 module Labimotion
   ## ElementEntity
-  class ElnElementEntity < ApplicationEntity
+  class ElnElementEntity < Labimotion::ApplicationEntity
     with_options(anonymize_below: 0) do
       expose! :created_by
       expose! :id

data/lib/labimotion/entities/generic_klass_entity.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
-#
+
 require 'labimotion/entities/application_entity'
 module Labimotion
-  # GenericKlassEntity
-  class GenericKlassEntity < ApplicationEntity
-    expose :id, :uuid, :label, :desc, :properties_template, :properties_release, :is_active, :version,
-          :place, :released_at, :identifier, :sync_time, :created_by, :updated_by, :created_at, :updated_at
-    expose_timestamps(timestamp_fields: [:released_at])
-    expose_timestamps(timestamp_fields: [:created_at])
-    expose_timestamps(timestamp_fields: [:updated_at])
-    expose_timestamps(timestamp_fields: [:sync_time])
+  class GenericKlassEntity < Labimotion::ApplicationEntity
+    expose :id, :uuid, :label, :desc, :is_active, :version, :place
+    expose :released_at, :identifier, :sync_time
+
+    expose :properties_template, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
+    expose :properties_release, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
+    expose_timestamps(timestamp_fields: %i[released_at created_at updated_at sync_time])
   end
 end

data/lib/labimotion/entities/generic_public_entity.rb

@@ -10,15 +10,17 @@ module Labimotion
     expose! :desc
     expose! :icon_name
     expose! :klass_prefix
-    expose! :klass_name
+    expose :klass_name do |obj|
+      obj[:name] || ''
+    end
     expose! :label
     expose! :identifier
     expose! :version
     expose! :released_at
-    expose! :properties_release, if: :displayed
+    expose :properties_release, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
     expose :element_klass do |obj|
       if obj[:element_klass_id]
-        { :label => obj.element_klass.label, :icon_name => obj.element_klass.icon_name }
+        { label: obj.element_klass.label, icon_name: obj.element_klass.icon_name, id: obj.element_klass_id }
       else
         {}
       end

data/lib/labimotion/entities/klass_revision_entity.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
+require 'labimotion/entities/application_entity'
 module Labimotion
+  # KlassRevisionEntity
   class KlassRevisionEntity < Labimotion::ApplicationEntity
-    expose :id, :uuid, :version, :released_at, :klass_id, :submitted
-    expose :properties_release, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
+    expose :id, :uuid, :properties_release, :version, :released_at
 
-    def klass_id
-      object.klass&.id
+    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
     end
 
     def released_at
@@ -14,3 +18,4 @@ module Labimotion
     end
   end
 end
+

data/lib/labimotion/entities/properties_entity.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'labimotion/entities/application_entity'
 
 module Labimotion

data/lib/labimotion/entities/segment_entity.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
 require 'labimotion/entities/application_entity'
+require 'labimotion/entities/properties_entity'
 module Labimotion
   ## Segment entity
-  class SegmentEntity < PropertiesEntity
-    expose :id, :segment_klass_id, :element_type, :element_id, :properties, :properties_release, :uuid, :klass_uuid, :klass_label
+  class SegmentEntity < Labimotion::PropertiesEntity
+    expose :id, :segment_klass_id, :element_type, :element_id, :uuid, :klass_uuid, :klass_label
+    expose :properties, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
+    expose :properties_release, **DISPLAYED_IN_LIST_CONDITION, anonymize_with: {}
 
     def klass_label
       object.segment_klass.label

data/lib/labimotion/entities/segment_revision_entity.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
-#
+
 require 'labimotion/entities/application_entity'
 module Labimotion
-  class SegmentRevisionEntity < ApplicationEntity
+  class SegmentRevisionEntity < Labimotion::ApplicationEntity
     expose :id, :segment_id, :uuid, :klass_uuid, :properties, :created_at
     def created_at
       object.created_at.strftime('%d.%m.%Y, %H:%M')

data/lib/labimotion/entities/vocabulary_entity.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
-#
+
 require 'labimotion/entities/application_entity'
 module Labimotion
   # Dataset entity
-  class VocabularyEntity < ApplicationEntity
+  class VocabularyEntity < Labimotion::ApplicationEntity
     expose :id, :identifier, :name, :label, :field_type, :opid, :term_id,
            :field_id, :properties, :source, :source_id, :layer_id
     expose :voc do |obj|

data/lib/labimotion/helpers/dataset_helpers.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
+
 require 'grape'
 module Labimotion
-    ## DatasetHelpers
+  ## DatasetHelpers
   module DatasetHelpers
     extend Grape::API::Helpers
 
-    def klass_list(is_active)
+    def klass_list(is_active, displayed_in_list = false)
+      scope = displayed_in_list ? Labimotion::DatasetKlass.for_list_display : Labimotion::DatasetKlass.all
       if is_active == true
-        Labimotion::DatasetKlass.where(is_active: true).order('place') || []
+        scope.where(is_active: true).order('place') || []
       else
-        Labimotion::DatasetKlass.all.order('place') || []
+        scope.order('place') || []
       end
     end