labimotion 2.0.0 → 2.1.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c1fa1527f921643836476d930d66fedc973e06e2a6300d9e100e2852fc96168
-  data.tar.gz: 4ccc2fe165c170aa98fba5db9d63c576ed997e9650e54da439b1b295da65c816
+  metadata.gz: 72992fcf1cd53788755bb3611e14712053e4b32e1891eb0c9a8bbdb2d3ce6d60
+  data.tar.gz: 4ef4a14c43343881dc69ea6ecab8fea6de0e4bd5dbee94ded1a0a1573baee931
 SHA512:
-  metadata.gz: 39915628df304676e86ad4e601d6776e994eb5007cc2f857c48b64498c24dba596d3ae1a46136b1d9c909dc3620724c10f0605682ba34224430c5405324d9076
-  data.tar.gz: fae1a472384cd8ba2c7e93c647399add301ed35e4404038382f451c6b2f2c7644331004c67cba91e76872e844b334fb8041e4a1dbf682dc6644010d9fd7630fe
+  metadata.gz: 5cb01613d7756d8e37e166f05f59fc0146055461bb719fe2ce863dd812e2a7ff190988a62ad3f984162686756a31e028abcd6e0658fcd11fb5e17072c5c4c596
+  data.tar.gz: 8d0e9282cd00ab1c00cac2e5fb9c42e5e59a39e8a39f337943e866f96a11de56fb35ada9278a46204cd404fc40674b0be751111dddfd7c5ff1408ed1d5c4a6f4

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

@@ -188,7 +188,7 @@ module Labimotion
         get do
           klass = Labimotion::Segment.find(params[:id])
           list = klass.segments_revisions unless klass.nil?
-          present list&.sort_by(&:created_at).reverse, with: Labimotion::SegmentRevisionEntity, root: 'revisions'
+          present list&.order(created_at: :desc)&.limit(10), with: Labimotion::SegmentRevisionEntity, root: 'revisions'
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)
           []
@@ -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/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/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,8 +1,9 @@
 # frozen_string_literal: true
 
+require 'labimotion/entities/application_entity'
 module Labimotion
   # KlassRevisionEntity
-  class KlassRevisionEntity < ApplicationEntity
+  class KlassRevisionEntity < Labimotion::ApplicationEntity
     expose :id, :uuid, :properties_release, :version, :released_at
 
     expose :klass_id do |object|

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
 

data/lib/labimotion/helpers/element_helpers.rb

@@ -93,12 +93,13 @@ module Labimotion
       all_coll = Collection.get_all_collection_for_user(current_user.id)
       element.collections << all_coll
       element.save!
-      _properties = update_sample_association(params[:properties], current_user, element)
-      element.properties = update_vocabularies(_properties, current_user, element)
+      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)
       element.save_segments(segments: params[:segments], current_user_id: current_user.id)
+      element.save!
       element
     rescue StandardError => e
       Labimotion.log_exception(e, current_user)
@@ -129,9 +130,11 @@ module Labimotion
         attributes['klass_uuid'] = properties['klass_uuid']
         element.update_columns(attributes)
       end
+      # element.save_segments(segments: params[:segments], current_user_id: current_user.id)
+      element.reload
       element.save_segments(segments: params[:segments], current_user_id: current_user.id)
       element.reload
-      element.properties = update_vocabularies(element.properties, current_user, element)
+      # element.properties = update_vocabularies(element.properties, current_user, element)
       ## element.user_for_revision = current_user
       element.save!
       element
@@ -192,7 +195,7 @@ module Labimotion
     def element_revisions(params)
       klass = Labimotion::Element.find(params[:id])
       list = klass.elements_revisions unless klass.nil?
-      list&.sort_by(&:created_at)&.reverse&.first(10)
+      list&.order(created_at: :desc)&.limit(10)
     rescue StandardError => e
       Labimotion.log_exception(e, current_user)
       raise e

data/lib/labimotion/helpers/segment_helpers.rb

@@ -8,8 +8,8 @@ module Labimotion
   module SegmentHelpers
     extend Grape::API::Helpers
 
-    def klass_list(el_klass, is_active=false)
-      scope = Labimotion::SegmentKlass.all
+    def klass_list(el_klass, is_active = false, displayed_in_list = false)
+      scope = displayed_in_list ? Labimotion::SegmentKlass.for_list_display : Labimotion::SegmentKlass.all
       scope = scope.where(is_active: is_active) if is_active.present? && is_active == true
       scope = scope.joins(:element_klass).where(klass_element: params[:element], is_active: true).preload(:element_klass) if el_klass.present?
       scope.order('place') || []

data/lib/labimotion/libs/data/mapper/Chemwiki.json

@@ -197,7 +197,7 @@
         "type": "string"
       },
       "redox": {
-        "title": "Redox-Potential",
+        "title": "Redox potential",
         "param": 6,
         "type": "spc"
       },
@@ -233,4 +233,4 @@
       }
     }
   }
-}
+}

data/lib/labimotion/libs/properties_handler.rb

@@ -91,5 +91,15 @@ module Labimotion
       Labimotion.log_exception(e)
       properties
     end
+
+    # Update field with value
+    def self.update_field_value!(properties, layer_key, field_index, value)
+      properties[Labimotion::Prop::LAYERS][layer_key][Labimotion::Prop::FIELDS][field_index]['value'] = value
+    end
+
+    # Delete field key
+    def self.delete_field_key!(properties, layer_key, field_index, key)
+      properties[Labimotion::Prop::LAYERS][layer_key][Labimotion::Prop::FIELDS][field_index].delete(key)
+    end
   end
 end

data/lib/labimotion/libs/vocabulary_handler.rb

@@ -4,8 +4,10 @@ module Labimotion
   class VocabularyHandler
     class << self
       def update_vocabularies(properties, current_user, element)
+        return properties if properties.nil? || !properties.is_a?(Hash) || properties[Labimotion::Prop::LAYERS].nil?
+
         properties[Labimotion::Prop::LAYERS].each do |key, layer|
-          update_layer_vocabularies(layer, key, properties, current_user, element)
+          update_layer_vocabularies!(layer, key, properties, current_user, element)
         end
         properties
       rescue StandardError => e
@@ -23,12 +25,12 @@ module Labimotion
 
       private
 
-      def update_layer_vocabularies(layer, key, properties, current_user, element)
+      def update_layer_vocabularies!(layer, key, properties, current_user, element)
         field_vocabularies = layer[Labimotion::Prop::FIELDS].select { |field| field['is_voc'] }
         field_vocabularies.each do |field|
           idx = layer[Labimotion::Prop::FIELDS].index(field)
           val = get_vocabulary_value(field, current_user, element)
-          update_field_value(properties, key, idx, val) if val.present?
+          update_field_value!(properties, key, idx, val)
         end
       end
 
@@ -44,6 +46,7 @@ module Labimotion
           get_segment_value(field, element)
         when 'Dataset'
           # TODO: Implement Dataset logic here
+          # TODO: Update datasetable.save_dataset
           nil
         end
       end
@@ -91,9 +94,8 @@ module Labimotion
         fields.find { |ss| ss['field'] == field['field_id'] }&.dig('value')
       end
 
-      def update_field_value(properties, key, idx, val)
-        properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = val
-        properties
+      def update_field_value!(properties, key, idx, val)
+        Labimotion::PropertiesHandler.update_field_value!(properties, key, idx, val)
       end
 
       def load_from_files

data/lib/labimotion/models/concerns/datasetable.rb

@@ -42,15 +42,15 @@ module Labimotion
       props['identifier'] = klass.identifier if klass.identifier.present?
       props['uuid'] = uuid
       props['klass'] = 'Dataset'
+      props['klass_uuid'] = klass.uuid
       props = Labimotion::VocabularyHandler.update_vocabularies(props, args[:current_user], args[:element])
 
       ds = Labimotion::Dataset.find_by(element_type: self.class.name, element_id: id)
-      if ds.present? && (ds.klass_uuid != props['klass_uuid'] || ds.properties != props)
-        ds.update!(properties_release: klass.properties_release, uuid: uuid, dataset_klass_id: args[:dataset_klass_id], properties: props, klass_uuid: props['klass_uuid'])
+      if ds.present? && (ds.klass_uuid != klass.uuid || ds.properties != props)
+        ds.update!(properties_release: klass.properties_release, uuid: uuid, dataset_klass_id: args[:dataset_klass_id], properties: props, klass_uuid: klass.uuid)
       end
       return if ds.present?
 
-      props['klass_uuid'] = klass.uuid
       Labimotion::Dataset.create!(properties_release: klass.properties_release, uuid: uuid, dataset_klass_id: args[:dataset_klass_id], element_type: self.class.name, element_id: id, properties: props, klass_uuid: klass.uuid)
     end
 

data/lib/labimotion/models/concerns/generic_klass.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Labimotion
+  ## Generic Klass Helpers
+  module GenericKlass
+    extend ActiveSupport::Concern
+
+    included do
+      # Scope for active and released templates
+      scope :active_and_released, -> { for_list_display.where(is_active: true).where.not(released_at: nil) }
+
+      # Scope for active, released, and generic templates (primarily for ElementKlass)
+      scope :active_released_generic, -> { active_and_released.where(is_generic: true) }
+    end
+  end
+end

data/lib/labimotion/models/concerns/segmentable.rb

@@ -46,11 +46,17 @@ module Labimotion
       end
     end
 
+    def touch_vocabulary(current_user)
+      touch_element_properties(current_user) if instance_of?(::Labimotion::Element)
+      touch_segments_properties(current_user)
+      touch_analyses_properties(current_user)
+    end
+
     def save_segments(**args) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-      return if args[:segments].nil?
+      args_segments = args[:segments] || []
 
-      segments = []
-      args[:segments]&.each do |seg|
+      current_user = User.find_by(id: args[:current_user_id])
+      args_segments.each do |seg|
         klass = Labimotion::SegmentKlass.find_by(id: seg['segment_klass_id'])
         uuid = SecureRandom.uuid
         props = seg['properties']
@@ -59,21 +65,52 @@ module Labimotion
         props['uuid'] = uuid
         props['klass'] = 'Segment'
         props = Labimotion::SampleAssociation.update_sample_association(props, args[:current_user_id])
-        current_user = User.find_by(id: args[:current_user_id])
-        props = Labimotion::VocabularyHandler.update_vocabularies(props, current_user, self)
+        # props = Labimotion::VocabularyHandler.update_vocabularies(props, current_user, self)
         segment = Labimotion::Segment.where(element_type: self.class.name, element_id: self.id, segment_klass_id: seg['segment_klass_id']).order(id: :desc).first
         if segment.present? && (segment.klass_uuid != props['klass_uuid'] || segment.properties != props)
           segment.update!(properties_release: klass.properties_release, properties: props, uuid: uuid, klass_uuid: props['klass_uuid'])
-          segments.push(segment)
+          # segments.push(segment)
           Labimotion::Segment.where(element_type: self.class.name, element_id: self.id, segment_klass_id: seg['segment_klass_id']).where.not(id: segment.id).destroy_all
         end
         next if segment.present?
 
         props['klass_uuid'] = klass.uuid
         segment = Labimotion::Segment.create!(properties_release: klass.properties_release, segment_klass_id: seg['segment_klass_id'], element_type: self.class.name, element_id: self.id, properties: props, created_by: args[:current_user_id], uuid: uuid, klass_uuid: klass.uuid)
-        segments.push(segment)
+        # segments.push(segment)
       end
+
+      self.reload
+      touch_vocabulary(current_user)
+      self.reload
       segments
     end
+
+    def touch_element_properties(current_user)
+      touch_properties_for_object(self, current_user)
+    end
+
+    def touch_segments_properties(current_user)
+      segments.each do |segment|
+        touch_properties_for_object(segment, current_user)
+      end
+    end
+
+    def touch_analyses_properties(current_user)
+      analyses.each do |analysis|
+        analysis.children.each do |child|
+          dataset = child.dataset
+          next if dataset.nil?
+
+          touch_properties_for_object(dataset, current_user)
+        end
+      end
+    end
+
+    # NOTE: Update bypassing validations, callbacks, and timestamp updates
+    def touch_properties_for_object(object, current_user)
+      props_dup = object.properties.deep_dup
+      Labimotion::VocabularyHandler.update_vocabularies(props_dup, current_user, self)
+      object.update_column(:properties, props_dup) if props_dup != object.properties
+    end
   end
 end

data/lib/labimotion/models/dataset_klass.rb

@@ -1,22 +1,35 @@
 # frozen_string_literal: true
+
 require 'labimotion/models/concerns/generic_klass_revisions'
+require 'labimotion/models/concerns/generic_klass'
 
 module Labimotion
   class DatasetKlass < ApplicationRecord
     acts_as_paranoid
     self.table_name = :dataset_klasses
     include GenericKlassRevisions
+    include GenericKlass
     has_many :datasets, dependent: :destroy, class_name: 'Labimotion::Dataset'
     has_many :dataset_klasses_revisions, dependent: :destroy, class_name: 'Labimotion::DatasetKlassesRevision'
 
+    # Scope for displayed_in_list - select only necessary columns for list view
+    scope :for_list_display, lambda {
+      select(:id, :uuid, :label, :desc, :is_active, :version, :place, :released_at,
+             :identifier, :sync_time, :created_at, :updated_at, :ols_term_id)
+    }
+
     def self.init_seeds
-      seeds_path = File.join(Rails.root, 'db', 'seeds', 'json', 'dataset_klasses.json')
+      gem_spec = Gem.loaded_specs['labimotion']
+      gem_root = gem_spec.gem_dir if gem_spec
+      seeds_path = File.join(gem_root, 'db', 'seeds', 'dataset_klasses.json')
       seeds = JSON.parse(File.read(seeds_path))
 
       seeds['chmo'].each do |term|
         next if Labimotion::DatasetKlass.where(ols_term_id: term['id']).count.positive?
 
-        attributes = { ols_term_id: term['id'], label: "#{term['label']} (#{term['synonym']})", desc: "#{term['label']} (#{term['synonym']})", place: term['position'], created_by: Admin.first&.id || 0 }
+        attributes = { ols_term_id: term['id'], label: "#{term['label']} (#{term['synonym']})",
+                       desc: "#{term['label']} (#{term['synonym']})", place: term['position'],
+                       created_by: Admin.first&.id || 0 }
         Labimotion::DatasetKlass.create!(attributes)
       end
       true

data/lib/labimotion/models/element.rb

@@ -31,6 +31,7 @@ module Labimotion
 
     belongs_to :element_klass, class_name: 'Labimotion::ElementKlass'
 
+    # has_ancestry ancestry_format: :materialized_path2
     has_ancestry orphan_strategy: :adopt
 
     has_many :collections_elements,  inverse_of: :element, dependent: :destroy, class_name: 'Labimotion::CollectionsElement'
@@ -49,6 +50,7 @@ module Labimotion
     scope :elements_updated_time_to, ->(time) { where('elements.updated_at <= ?', time) }
 
     belongs_to :creator, foreign_key: :created_by, class_name: 'User'
+    before_validation :set_root_ancestry_if_nil
     validates :creator, presence: true
 
     has_many :elements_elements, foreign_key: :parent_id, class_name: 'Labimotion::ElementsElement'
@@ -71,7 +73,7 @@ module Labimotion
     end
 
     def analyses
-      container ? container.analyses : []
+      container ? container.analyses : Container.none
     end
 
     def auto_set_short_label
@@ -148,5 +150,9 @@ module Labimotion
         attachments.each(&:destroy!)
       end
     end
+
+    def set_root_ancestry_if_nil
+      self.ancestry ||= '/'
+    end
   end
 end

data/lib/labimotion/models/element_klass.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
+
 require 'labimotion/conf'
 require 'labimotion/models/concerns/generic_klass_revisions'
+require 'labimotion/models/concerns/generic_klass'
 require 'labimotion/models/concerns/workflow'
 
 module Labimotion
@@ -8,11 +10,19 @@ module Labimotion
     self.table_name = :element_klasses
     acts_as_paranoid
     include GenericKlassRevisions
+    include GenericKlass
     include Workflow
     has_many :elements, dependent: :destroy, class_name: 'Labimotion::Element'
     has_many :segment_klasses, dependent: :destroy, class_name: 'Labimotion::SegmentKlass'
     has_many :element_klasses_revisions, dependent: :destroy, class_name: 'Labimotion::ElementKlassesRevision'
 
+    # Scope for displayed_in_list - select only necessary columns for list view
+    scope :for_list_display, lambda {
+      select(:id, :uuid, :label, :desc, :is_active, :version, :place, :released_at,
+             :identifier, :sync_time, :created_at, :updated_at, :name, :icon_name,
+             :klass_prefix, :is_generic)
+    }
+
     def self.gen_klasses_json
       klasses = where(is_active: true, is_generic: true).order('place')&.pluck(:name) || []
     rescue ActiveRecord::StatementInvalid, PG::ConnectionBad, PG::UndefinedTable
@@ -24,6 +34,5 @@ module Labimotion
         klasses&.to_json || []
       )
     end
-
   end
 end

data/lib/labimotion/models/segment_klass.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
+
 require 'labimotion/models/concerns/generic_klass_revisions'
+require 'labimotion/models/concerns/generic_klass'
 require 'labimotion/models/concerns/workflow'
 
 module Labimotion
@@ -7,20 +9,24 @@ module Labimotion
     self.table_name = :segment_klasses
     acts_as_paranoid
     include GenericKlassRevisions
+    include GenericKlass
     include Workflow
     belongs_to :element_klass, class_name: 'Labimotion::ElementKlass'
     has_many :segments, dependent: :destroy, class_name: 'Labimotion::Segment'
     has_many :segment_klasses_revisions, dependent: :destroy, class_name: 'Labimotion::SegmentKlassesRevision'
 
+    # Scope for displayed_in_list - select only necessary columns for list view
+    scope :for_list_display, lambda {
+      select(:id, :uuid, :label, :desc, :is_active, :version, :place, :released_at,
+             :identifier, :sync_time, :created_at, :updated_at, :element_klass_id)
+    }
+
     def self.gen_klasses_json
       klasses = where(is_active: true)&.pluck(:name) || []
     rescue ActiveRecord::StatementInvalid, PG::ConnectionBad, PG::UndefinedTable
       klasses = []
     ensure
-      File.write(
-        Rails.root.join('config', 'segment_klass.json'),
-        klasses&.to_json || []
-      )
+      Rails.root.join('config', 'segment_klass.json').write(klasses&.to_json || [])
     end
   end
 end

data/lib/labimotion/version.rb

@@ -2,5 +2,5 @@
 
 ## Labimotion Version
 module Labimotion
-  VERSION = '2.0.0'
-end
+  VERSION = '2.1.0.rc2'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0.rc2
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-03-25 00:00:00.000000000 Z
+date: 2025-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -91,6 +91,7 @@ files:
 - lib/labimotion/models/collections_element.rb
 - lib/labimotion/models/concerns/attachment_converter.rb
 - lib/labimotion/models/concerns/datasetable.rb
+- lib/labimotion/models/concerns/generic_klass.rb
 - lib/labimotion/models/concerns/generic_klass_revisions.rb
 - lib/labimotion/models/concerns/generic_revisions.rb
 - lib/labimotion/models/concerns/linked_properties.rb
@@ -143,9 +144,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.1.6
 signing_key: