labimotion 2.0.0 → 2.1.0.rc11

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')
@@ -13,6 +13,8 @@ module Labimotion
       object.properties[Labimotion::Prop::LAYERS]&.keys.each do |key|
         field_sample_molecules = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_SAMPLE || ss['type'] == Labimotion::FieldType::DRAG_MOLECULE }
         field_sample_molecules.each do |field|
+          next unless field['value'].is_a?(Hash)
+
           idx = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
           sid = field.dig('value', 'el_id')
           next unless sid.present?

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
@@ -30,6 +30,8 @@ module Labimotion
           ss['type'] == Labimotion::FieldType::DRAG_SAMPLE || ss['type'] == Labimotion::FieldType::DRAG_MOLECULE
         end
         field_sample_molecules.each do |field|
+          next unless field['value'].is_a?(Hash)
+
           idx = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
           sid = field.dig('value', 'el_id')
           next unless sid.present?

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
@@ -57,6 +58,8 @@ module Labimotion
     end
 
     def update_sample_or_molecule_field(key, field, idx)
+      return unless field['value'].is_a?(Hash)
+
       sid = field.dig('value', 'el_id')
       return unless sid.present?
 
@@ -78,6 +81,8 @@ module Labimotion
     end
 
     def update_reaction_field(key, field, idx)
+      return unless field['value'].is_a?(Hash)
+
       sid = field.dig('value', 'el_id')
       return unless sid.present?
 

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')
@@ -12,6 +12,8 @@ module Labimotion
       object.properties[Labimotion::Prop::LAYERS]&.keys.each do |key|
         field_sample_molecules = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_SAMPLE || ss['type'] == Labimotion::FieldType::DRAG_MOLECULE }
         field_sample_molecules.each do |field|
+          next unless field['value'].is_a?(Hash)
+
           idx = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS].index(field)
           sid = field.dig('value', 'el_id')
           next unless sid.present?

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

@@ -2,12 +2,25 @@
 require 'grape'
 
 module Labimotion
-  ## ElementHelpers
+  ## ConverterHelpers
   module ConverterHelpers
     extend Grape::API::Helpers
 
-    def demo(params)
-      ### TODO: implement demo
+    # Update the general_description field in the container's extended_metadata
+    def self.update_general_description(container, current_user, date: nil, time: nil)
+      return unless container.present?
+
+      desc = container.extended_metadata['general_description']
+
+      general_desc = desc if desc.present? && desc.is_a?(Hash)
+      general_desc = JSON.parse(container.extended_metadata['general_description']) if desc.present? && desc.is_a?(String)
+      general_desc = {} unless general_desc.is_a?(Hash)
+      general_desc['creator'] = current_user.name if current_user.present?
+      general_desc['date'] = date if date.present?
+      general_desc['time'] = time if time.present?
+
+      container.extended_metadata['general_description'] = general_desc.to_json
+      container.save!
     end
   end
 end

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
 
@@ -31,18 +33,41 @@ module Labimotion
           ds = Labimotion::DatasetKlass.find_by(ols_term_id: attributes['ols_term_id'])
           ds.update!(attributes)
           ds.create_klasses_revision(current_user)
-          { status: 'success', message: "This dataset: [#{attributes['label']}] has been upgraded to the version: #{attributes['version']}!" }
+          { status: 'success',
+            message: "This dataset: [#{attributes['label']}] has been upgraded to the version: #{attributes['version']}!" }
         end
       else
         attributes['created_by'] = current_user.id
         ds = Labimotion::DatasetKlass.create!(attributes)
         ds.create_klasses_revision(current_user)
-        { status: 'success', message: "The dataset: #{attributes['label']} has been created using version: #{attributes['version']}!" }
+        { status: 'success',
+          message: "The dataset: #{attributes['label']} has been created using version: #{attributes['version']}!" }
       end
     rescue StandardError => e
       Labimotion.log_exception(e, current_user)
       # { error: e.message }
       raise e
     end
+
+    def find_best_match_template(ols_term_id)
+      result = Labimotion::TemplateMatcher.find_best_match(ols_term_id)
+      if result[:template]
+        build_template_response(result[:template], result[:match_type], result[:info_messages])
+      else
+        { error: '', data: {}, info: "No matching template found for term id [#{ols_term_id}]" }
+      end
+    end
+
+    private
+
+    def build_template_response(template, match_type, info_messages)
+      response = {
+        error: '',
+        data: Labimotion::DatasetKlassEntity.represent(template, displayed_in_list: false),
+        match_type: match_type
+      }
+      response[:info] = info_messages.join('; ') if info_messages.any?
+      response
+    end
   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/exporter_helpers.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # ExporterHelpers provides utility methods for formatting and processing export data
+  module ExporterHelpers
+    # Constants
+    CONST_UNNAMED = '(Unnamed)'
+
+    # Normalize column name, returns CONST_UNNAMED for blank values
+    def normalize_column_name(col_name)
+      return CONST_UNNAMED if col_name.nil? || col_name.to_s.strip.empty?
+
+      col_name
+    end
+
+    # Check if field type should be expanded (DRAG_SAMPLE or DRAG_MOLECULE)
+    def expandable_field?(field_type)
+      [Labimotion::FieldType::DRAG_SAMPLE, Labimotion::FieldType::DRAG_MOLECULE].include?(field_type)
+    end
+
+    # Generate sanitized filename for export
+    def generate_filename(element_name, segment_name, layer_name, field_name)
+      timestamp = Time.zone.now.strftime('%Y%m%d_%H%M%S')
+      parts = [element_name]
+      parts << segment_name unless segment_name.empty?
+      parts.push(layer_name, field_name, timestamp)
+      parts.join('_').gsub(/\s+/, '_').gsub(/[()]/, '(' => '[', ')' => ']')
+    end
+
+    # Format table cell value based on field type
+    def format_table_cell(sub_val, sub_field)
+      return '' if sub_field.fetch('id', nil).nil? || sub_val[sub_field['id']].nil?
+
+      case sub_field['type']
+      when Labimotion::FieldType::DRAG_SAMPLE, Labimotion::FieldType::DRAG_MOLECULE
+        format_drag_field_cell(sub_val, sub_field)
+      when Labimotion::FieldType::SELECT
+        format_select_cell(sub_val, sub_field)
+      when Labimotion::FieldType::SYSTEM_DEFINED
+        format_system_defined_cell(sub_val, sub_field)
+      else
+        format_default_cell(sub_val, sub_field)
+      end
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      ''
+    end
+
+    # Format expanded cell for DRAG_SAMPLE or DRAG_MOLECULE with sub-headers
+    def format_expanded_cell(sub_val, exp_field)
+      field_id = exp_field['id']
+      sub_header = exp_field['sub_header']
+
+      return '' if field_id.nil? || sub_val[field_id].nil?
+
+      val = sub_val[field_id]['value'] || {}
+      return '' if val.blank? || !val.is_a?(Hash)
+
+      property_key = map_sub_header_to_property(sub_header)
+      val[property_key].to_s
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      ''
+    end
+
+    # Map sub-header to property key
+    def map_sub_header_to_property(sub_header)
+      property_map = {
+        'name' => 'el_name',
+        'label' => 'el_label',
+        'short_label' => 'el_short_label',
+        'external_label' => 'el_external_label',
+        'molecular_weight' => 'el_molecular_weight',
+        'smiles' => 'el_smiles',
+        'inchikey' => 'el_inchikey',
+        'iupac' => 'el_iupac',
+        'sum_formula' => 'el_sum_formula',
+        'decoupled' => 'el_decoupled'
+      }
+
+      property_map[sub_header] || "el_#{sub_header}"
+    end
+
+    # Format drag field cell (DRAG_SAMPLE or DRAG_MOLECULE), returns hyperlink or label
+    def format_drag_field_cell(sub_val, sub_field)
+      val = sub_val[sub_field['id']]['value'] || {}
+      return '' if val.blank?
+
+      svg_url = val['el_svg'].to_s
+      if svg_url.present?
+        full_url = URI.join(Rails.application.config.root_url, svg_url).to_s
+        { hyperlink: full_url, text: '[image link]' }
+      else
+        val['el_label'].to_s
+      end
+    end
+
+    # Format select cell
+    def format_select_cell(sub_val, sub_field)
+      sub_val[sub_field['id']]['value'].to_s
+    end
+
+    # Format system-defined cell with unit
+    def format_system_defined_cell(sub_val, sub_field)
+      value = sub_val[sub_field['id']]['value'].to_s
+      unit = find_unit_label(sub_val, sub_field)
+
+      unit.present? ? "#{value} #{unit}" : value
+    end
+
+    # Find unit label for system-defined field
+    def find_unit_label(sub_val, sub_field)
+      value_system = extract_value_system(sub_val, sub_field)
+      find_unit_by_key(sub_field['option_layers'], value_system)
+    end
+
+    # Extract value_system from sub_val or sub_field
+    def extract_value_system(sub_val, sub_field)
+      field_data = sub_val[sub_field['id']]
+      field_data.is_a?(Hash) ? field_data['value_system'] : sub_field['value_system']
+    end
+
+    # Find unit label by field and key
+    def find_unit_by_key(option_layers, value_system)
+      field_config = Labimotion::Units::FIELDS.find { |o| o[:field] == option_layers }
+      return '' unless field_config
+
+      units = field_config.fetch(:units, [])
+      unit = units.find { |u| u[:key] == value_system }
+      unit ? unit.fetch(:label, '') : ''
+    end
+
+    # Format default cell
+    def format_default_cell(sub_val, sub_field)
+      cell_data = sub_val[sub_field['id']]
+      cell_data.is_a?(Hash) ? cell_data['value'].to_s : cell_data.to_s
+    end
+  end
+end

data/lib/labimotion/helpers/param_helpers.rb

@@ -134,5 +134,11 @@ module Labimotion
       optional :select_options, type: Hash, desc: 'selections'
       optional :option_layers, type: String, desc: 'option'
     end
+
+    params :table_xlsx_params do
+      requires :klass, type: String, desc: 'Generic Type', values: %w[Element Segment]
+      requires :layer_id, type: String, desc: 'layer identifier'
+      requires :field_id, type: String, desc: 'field identifier'
+    end
   end
 end

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

@@ -6,6 +6,7 @@ require 'json'
 require 'date'
 require 'labimotion/version'
 require 'labimotion/utils/utils'
+require 'labimotion/helpers/converter_helpers'
 
 # rubocop: disable Metrics/AbcSize
 # rubocop: disable Metrics/MethodLength
@@ -228,6 +229,19 @@ module Labimotion
     def self.update_ds(dataset, dsr, current_user = nil) # rubocop: disable Metrics/PerceivedComplexity
       layers = dataset.properties[Labimotion::Prop::LAYERS] || {}
       new_prop = dataset.properties
+
+      container = dataset.element
+
+      # Extract and update general description fields
+      general_dsr = dsr.select { |ds| ds[:layer] == 'general' }
+      if general_dsr.present?
+        date = general_dsr.find { |ds| ds[:field] == 'date' }&.dig(:value)
+        time = general_dsr.find { |ds| ds[:field] == 'time' }&.dig(:value)
+        Labimotion::ConverterHelpers.update_general_description(container, current_user, date: date, time: time)
+      else
+        Labimotion::ConverterHelpers.update_general_description(container, current_user)
+      end
+
       dsr.each do |ds|
         layer = layers[ds[:layer]]
         next if layer.blank? || layer[Labimotion::Prop::FIELDS].blank?