labimotion 2.0.3 → 2.1.0.rc1

data/lib/labimotion/helpers/element_helpers.rb

@@ -93,8 +93,8 @@ 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)
@@ -129,11 +129,13 @@ 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.save!
       element
     rescue StandardError => e
       Labimotion.log_exception(e, current_user)

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/template_hub.rb

@@ -5,6 +5,9 @@ require 'uri'
 require 'json'
 require 'date'
 
+# rubocop: disable Metrics/AbcSize
+# rubocop: disable Metrics/MethodLength
+
 module Labimotion
   ## TemplateHub
   class TemplateHub
@@ -15,11 +18,12 @@ module Labimotion
       "#{url}api/v1/labimotion_hub/#{api_name}"
     end
 
+
     def self.header(opt = {})
       opt || { timeout: 10, headers: { 'Content-Type' => 'text/json' } }
     end
 
-    def self.handle_response(oat, response)
+    def self.handle_response(oat, response) # rubocop: disable Metrics/PerceivedComplexity
       begin
         response&.success? ? 'OK' : 'ERROR'
       rescue StandardError => e
@@ -52,32 +56,10 @@ module Labimotion
       Labimotion.log_exception(e)
       error!('Cannot connect to Chemotion Repository', 401)
     end
-
-    def self.send_to_central_hub(klass, template, metadata, origin)
-      body = {
-        template_klass: klass,
-        template: template,
-        metadata: metadata,
-        origin: origin
-      }
-      response = HTTParty.post(
-        Labimotion::TemplateHub.uri('template_submissions'),
-        headers: {
-          'Content-Type' => 'application/json',
-          'X-Origin-URL' => origin
-        },
-        body: body.to_json,
-        timeout: 10
-      )
-
-      if [200, 201].include?(response.code)
-        parsed_response = JSON.parse(response.body)
-        return { mc: 'ss00', data: { id: parsed_response['id'] } }
-      end
-      { mc: 'se00', msg: "HTTP #{response.code}: #{response.message}", data: {} }
-    rescue StandardError => e
-      Labimotion.log_exception(e)
-      { mc: 'se00', msg: "Connection failure: #{e.message}", data: {} }
-    end
   end
 end
+
+# rubocop: enable Metrics/AbcSize
+# rubocop: enable Metrics/MethodLength
+# rubocop: enable Metrics/ClassLength
+# rubocop: enable Metrics/CyclomaticComplexity

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/dataset_klasses_revision.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 
-require 'labimotion/models/concerns/klass_revision'
-
 module Labimotion
   class DatasetKlassesRevision < ApplicationRecord
     self.table_name = :dataset_klasses_revisions
     acts_as_paranoid
-    include KlassRevision
-    belongs_to :dataset_klass, class_name: 'Labimotion::DatasetKlass'
+    has_one :dataset_klass, class_name: 'Labimotion::DatasetKlass'
   end
 end

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/element_klasses_revision.rb

@@ -1,15 +1,14 @@
 # frozen_string_literal: true
 
 require 'labimotion/models/concerns/workflow'
-require 'labimotion/models/concerns/klass_revision'
 
 module Labimotion
   class ElementKlassesRevision < ApplicationRecord
     acts_as_paranoid
     self.table_name = :element_klasses_revisions
     include Workflow
-    include KlassRevision
-    belongs_to :element_klass, class_name: 'Labimotion::ElementKlass'
+    has_one :element_klass, class_name: 'Labimotion::ElementKlass'
+
 
     def migrate_workflow
       return if properties_release.nil? || properties_release['flow'].nil?

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/models/segment_klasses_revision.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 
-require 'labimotion/models/concerns/klass_revision'
-
 module Labimotion
   class SegmentKlassesRevision < ApplicationRecord
     acts_as_paranoid
     self.table_name = :segment_klasses_revisions
-    include KlassRevision
-    belongs_to :segment_klass, class_name: 'Labimotion::SegmentKlass'
+    has_one :segment_klass, class_name: 'Labimotion::SegmentKlass'
   end
 end

data/lib/labimotion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.1.0.rc1
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-12-19 00:00:00.000000000 Z
+date: 2025-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -76,7 +76,6 @@ files:
 - lib/labimotion/helpers/vocabulary_helpers.rb
 - lib/labimotion/libs/attachment_handler.rb
 - lib/labimotion/libs/converter.rb
-- lib/labimotion/libs/data/layer/StdDataset.json
 - lib/labimotion/libs/data/mapper/Chemwiki.json
 - lib/labimotion/libs/data/mapper/Source.json
 - lib/labimotion/libs/data/vocab/Standard.json
@@ -92,9 +91,9 @@ 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/klass_revision.rb
 - lib/labimotion/models/concerns/linked_properties.rb
 - lib/labimotion/models/concerns/segmentable.rb
 - lib/labimotion/models/concerns/workflow.rb
@@ -115,7 +114,6 @@ files:
 - lib/labimotion/models/segments_revision.rb
 - lib/labimotion/models/std_layer.rb
 - lib/labimotion/models/std_layers_revision.rb
-- lib/labimotion/models/template_submission.rb
 - lib/labimotion/models/vocabulary.rb
 - lib/labimotion/utils/con_state.rb
 - lib/labimotion/utils/export_utils.rb
@@ -146,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: