labimotion 2.1.0.rc3 → 2.1.0.rc5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d084fef830351ae2182073c7c42a50abd49bc5bc3f20d256860da683ca6c5c8
-  data.tar.gz: 24b58889fdc9daeb36267aef35e736c81b56c3fc73dec3a1af06cd1148708875
+  metadata.gz: e23b274f29ceb300bbb97f91830dbe2fdc454966d229e88608cd434b6586a3b3
+  data.tar.gz: da620e95cb04ce10a69cba25d8cb63f22cb1e21142a1a6a3c93d9fecc33840aa
 SHA512:
-  metadata.gz: 1bb720347508e464f7f4a0786a7daaeeb0a9fa185efab31543adc28cb2addf0e57877e36128147755772097d46f8103a45275cc00134c1cff4af3f5b774f0e31
-  data.tar.gz: 0b9e694ebe9934be89a32147005c314614c3e26ad8f0f1fd79bd7c75207c936fbdc9bd0a594282a0a8c0434d4a4e9e73cf1f4b3d1418a807fc8cfb15c5fecda8
+  metadata.gz: db1827e8ad8c56f05c55215f3cd5e3830174f937875c2af49e7899dc4875180364111b1788eecc430b6f3ca8b39e3e0234eb21a3c1036c3b7ab064676f8bb4d1
+  data.tar.gz: 3f1667aa18030745ab178330cac70f234d4aa3eab46e3622546aeb4268aaf379e9d8dd0369060324327dd3db67efa2da6e94b6568feb33a88e987bec8030a737

data/lib/labimotion/apis/exporter_api.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # ExporterAPI handles exporting data to various formats (e.g., XLSX)
+  # The class length is justified due to the comprehensive helper methods needed for export functionality
+  class ExporterAPI < Grape::API
+    include Grape::Kaminari
+
+    helpers Labimotion::ParamHelpers
+    helpers Labimotion::ExporterHelpers
+
+    resource :exporter do
+      resource :table_xlsx do
+        desc 'Export single table field to XLSX format'
+        params do
+          use :table_xlsx_params
+        end
+        route_param :id do
+          before do
+            validate_and_authorize_request!
+          end
+
+          get do
+            layer = fetch_layer
+            field = fetch_field(layer)
+            validate_table_field!(field)
+
+            headers, expanded_sub_fields = build_table_headers(field)
+            rows = build_table_rows(field, expanded_sub_fields)
+
+            export_to_xlsx(layer, field, headers, rows)
+          rescue StandardError => e
+            Labimotion.log_exception(e, current_user)
+            error!("500 Internal Server Error: #{e.message}", 500)
+          end
+        end
+      end
+    end
+
+    # rubocop:disable Metrics/BlockLength
+    # The helpers block is necessarily large due to the many specialized helper methods
+    # for data fetching, validation, formatting, and export functionality
+    helpers do
+      # Validate and authorize the request, sets @element instance variable
+      def validate_and_authorize_request!
+        klass = fetch_klass
+        @element = klass.find_by(id: params[:id])
+
+        error!('404 Not Found', 404) if @element.nil?
+
+        authorize_element_access!
+      rescue ActiveRecord::RecordNotFound
+        error!('404 Not Found', 404)
+      rescue NameError => e
+        Labimotion.log_exception(e, current_user)
+        error!('400 Bad Request - Invalid type', 400)
+      end
+
+      # Fetch the element or segment class based on params
+      def fetch_klass
+        Labimotion::Utils.resolve_class(params[:klass])
+      end
+
+      # Authorize element access based on user permissions
+      def authorize_element_access!
+        element_policy = if params[:klass] == 'Element'
+                           ElementPolicy.new(current_user,
+                                             @element)
+                         else
+                           ElementPolicy.new(current_user,
+                                             @element.element)
+                         end
+        matrix_name = params[:klass] == 'Element' ? 'genericElement' : 'segment'
+
+        return if current_user.matrix_check_by_name(matrix_name) && element_policy.read?
+
+        error!('401 Unauthorized', 401)
+      end
+
+      # Fetch layer from element properties
+      def fetch_layer
+        properties = @element.properties
+        layers = properties[Labimotion::Prop::LAYERS] || {}
+        layer_key = params[:layer_id].to_s
+        layer = layers[layer_key]
+
+        error!('404 Layer Not Found', 404) if layer.nil?
+        layer
+      end
+
+      # Fetch field from layer
+      def fetch_field(layer)
+        fields = layer[Labimotion::Prop::FIELDS] || []
+        field = fields.find { |f| f['field'] == params[:field_id].to_s }
+
+        error!('404 Field Not Found', 404) if field.nil?
+        field
+      end
+
+      # Validate that the field is a table type
+      def validate_table_field!(field)
+        return if field['type'] == Labimotion::FieldType::TABLE
+
+        error!('400 Bad Request - Field is not a table type', 400)
+      end
+
+      # Build table headers from field definition, expands DRAG_SAMPLE and DRAG_MOLECULE columns
+      def build_table_headers(field)
+        sub_fields = field.fetch('sub_fields', [])
+        headers = []
+        expanded_sub_fields = []
+
+        sub_fields.each do |sf|
+          base_col_name = normalize_column_name(sf['col_name'])
+
+          if expandable_field?(sf['type'])
+            headers, expanded_sub_fields = expand_field_columns(sf, base_col_name, headers, expanded_sub_fields)
+          else
+            headers << base_col_name
+            expanded_sub_fields << sf
+          end
+        end
+
+        [headers, expanded_sub_fields]
+      end
+
+      # Expand field columns for DRAG_SAMPLE and DRAG_MOLECULE with sub-headers
+      def expand_field_columns(sub_field, base_col_name, headers, expanded_sub_fields)
+        sub_headers = sub_field['value'].to_s.split(';').reject(&:empty?)
+
+        # Always add the base column first (for SVG image link)
+        headers << base_col_name
+        expanded_sub_fields << sub_field
+
+        # For DRAG_SAMPLE, add a second base column for short_label
+        if sub_field['type'] == Labimotion::FieldType::DRAG_SAMPLE
+          headers << 'short_label'
+          expanded_sub_fields << {
+            'id' => sub_field['id'],
+            'type' => sub_field['type'],
+            'sub_header' => 'short_label',
+            'original' => sub_field,
+            'is_base_column' => true
+          }
+        end
+
+        # Add extra columns for each sub-header
+        sub_headers.each do |sub_header|
+          headers << sub_header
+          expanded_sub_fields << {
+            'id' => sub_field['id'],
+            'type' => sub_field['type'],
+            'sub_header' => sub_header,
+            'original' => sub_field
+          }
+        end
+
+        [headers, expanded_sub_fields]
+      end
+
+      # Build table rows from field data
+      def build_table_rows(field, expanded_sub_fields)
+        sub_values = field.fetch('sub_values', [])
+
+        sub_values.map do |sub_val|
+          expanded_sub_fields.map do |exp_field|
+            if exp_field.is_a?(Hash) && exp_field['sub_header']
+              format_expanded_cell(sub_val, exp_field)
+            else
+              format_table_cell(sub_val, exp_field)
+            end
+          end
+        end
+      end
+
+      # Export data to XLSX format
+      def export_to_xlsx(layer, field, headers, rows)
+        element_name = @element.is_a?(Labimotion::Segment) ? @element.element.name : @element.name
+        segment_name = @element.is_a?(Labimotion::Segment) ? @element.segment_klass.label : ''
+        selected_layer = "#{layer['label'] || ExporterHelpers::CONST_UNNAMED} (#{layer['key']})"
+        selected_field = field['label'] || ExporterHelpers::CONST_UNNAMED
+
+        filename = generate_filename(element_name, segment_name, selected_layer, selected_field)
+        exporter = Labimotion::XlsxExporter.new(filename)
+
+        worksheet_params = {
+          exporter: exporter,
+          element_name: element_name,
+          layer_name: selected_layer,
+          field_name: selected_field,
+          headers: headers,
+          rows: rows
+        }
+        worksheet_params[:segment_name] = segment_name unless segment_name.empty?
+        populate_worksheet(worksheet_params)
+
+        # Set response headers and format
+        configure_xlsx_response(exporter)
+
+        exporter.read
+      end
+
+      # Build metadata array for worksheet
+      def build_metadata(params)
+        metadata = [['Element:', params[:element_name]]]
+        metadata << ['Segment:', params[:segment_name]] if params[:segment_name].present?
+        metadata.push(
+          ['Layer:', params[:layer_name]],
+          ['Field:', params[:field_name]],
+          ['Exported at:', Time.zone.now.strftime('%Y-%m-%d %H:%M:%S')],
+          ['Exported by:', current_user.name]
+        )
+        metadata
+      end
+
+      # Populate worksheet with data
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def populate_worksheet(params)
+        # Store params in local variables for use in the instance_eval block
+        table_headers = params[:headers]
+        table_rows = params[:rows]
+        metadata = build_metadata(params)
+
+        params[:exporter].add_worksheet('Table Data') do |sheet|
+          # Add metadata section
+          sheet.add_section('Table Information', metadata)
+
+          # Add table data with headers
+          header_row_index = sheet.add_header(table_headers)
+
+          # Add data rows with hyperlink support
+          table_rows.each do |row_data|
+            # Process row data to handle hyperlinks
+            processed_row = row_data.map do |cell_value|
+              cell_value.is_a?(Hash) && cell_value[:hyperlink] ? cell_value[:text] : cell_value
+            end
+
+            # Add the row
+            row_index = sheet.add_row(processed_row)
+
+            # Add hyperlinks to cells that need them
+            row_data.each_with_index do |cell_value, col_index|
+              next unless cell_value.is_a?(Hash) && cell_value[:hyperlink]
+
+              sheet.add_hyperlink(row_index, col_index, cell_value[:hyperlink])
+            end
+          end
+
+          # Auto-fit columns and freeze panes
+          sheet.auto_fit_columns
+          sheet.freeze_panes(header_row_index + 1, 0) if table_headers.any?
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      # Set XLSX response headers with proper encoding
+      def configure_xlsx_response(exporter)
+        env['api.format'] = :binary
+        content_type 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+
+        # Use both filename and filename* for better browser compatibility
+        filename = exporter.filename
+        encoded_filename = URI.encode_www_form_component(filename)
+        header('Content-Disposition', "attachment; filename=\"#{filename}\"; filename*=UTF-8''#{encoded_filename}")
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end

data/lib/labimotion/apis/generic_dataset_api.rb

@@ -4,6 +4,7 @@ module Labimotion
   ## Generic Dataset API
   class GenericDatasetAPI < Grape::API
     include Grape::Kaminari
+
     helpers Labimotion::GenericHelpers
     helpers Labimotion::DatasetHelpers
 
@@ -24,7 +25,8 @@ module Labimotion
         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])
+          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)
@@ -32,7 +34,8 @@ module Labimotion
         end
       end
 
-      # Deprecated: This namespace is no longer used, but kept for backward compatibility. It is replaced by `list_klass`.
+      # 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
@@ -65,6 +68,20 @@ module Labimotion
           { error: e.message }
         end
       end
+
+      namespace :find_template do
+        desc 'Find best matching template for given OLS term ID'
+        params do
+          requires :ols_term_id, type: String, desc: 'OLS Term ID (e.g., CHMO:0000470)'
+        end
+        get do
+          result = find_best_match_template(params[:ols_term_id])
+          result
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          raise e
+        end
+      end
     end
   end
 end

data/lib/labimotion/apis/generic_element_api.rb

@@ -59,6 +59,65 @@ module Labimotion
         end
       end
 
+      namespace :search_by_like do
+        desc 'Search elements by name (case-insensitive like search)'
+        params do
+          requires :name, type: String, desc: 'Search query for element name'
+          requires :short_label, type: String, desc: 'Search query for element short label'
+          requires :klass_id, type: Integer, desc: 'Filter by element klass id'
+          optional :limit, type: Integer, desc: 'Maximum number of results', default: 20
+        end
+        get do
+          scope = Labimotion::Element.fetch_for_user(
+            current_user.id,
+            name: params[:name],
+            short_label: params[:short_label],
+            klass_id: params[:klass_id],
+            limit: params[:limit]
+          )
+
+          results = scope.map do |element|
+            Labimotion::ElementLookupEntity.represent(element)
+          end
+
+          { elements: results, total_count: results.count }
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          { elements: [], total_count: 0, error: e.message }
+        end
+      end
+
+      namespace :search_basic_by_like do
+        desc 'Search basic elements by name and short label (case-insensitive like search)'
+        params do
+          requires :klass_name, type: String, desc: 'Class name (device_description or wellplate or ...etc.)', default: 'device_description'
+          requires :name, type: String, desc: 'Search query for basic element name'
+          requires :short_label, type: String, desc: 'Search query for basic element short label'
+          optional :limit, type: Integer, desc: 'Maximum number of results', default: 20
+        end
+        get do
+          # Convert snake_case to PascalCase (e.g. device_description -> DeviceDescription)
+          klass_name = params[:klass_name].camelize
+          klass = "Labimotion::#{klass_name}".constantize
+
+          scope = klass.fetch_for_user(
+            current_user.id,
+            name: params[:name],
+            short_label: params[:short_label],
+            limit: params[:limit]
+          )
+
+          results = scope.map do |record|
+            Labimotion::ElementLookupEntity.represent(record)
+          end
+
+          { elements: results, total_count: results.count }
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          { elements: [], total_count: 0, error: e.message }
+        end
+      end
+
       namespace :export do
         desc 'export element'
         params do
@@ -225,12 +284,13 @@ module Labimotion
         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 :is_active, type: Boolean, desc: 'Active or Inactive'
           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)
+          scope = scope.where(is_active: params[:is_active]) if params.key?(:is_active)
 
           list = scope.sort_by(&:place)
           present list, with: Labimotion::ElementKlassEntity, root: 'klass', displayed_in_list: params[:displayed_in_list]
@@ -465,4 +525,25 @@ module Labimotion
       end
     end
   end
+
+  # Entity for element lookup by name response
+  class ElementLookupEntity < Grape::Entity
+    expose :id
+    expose :name
+    expose :short_label do |element|
+      element.respond_to?(:short_label) ? element.short_label : nil
+    end
+    expose :element_klass_id, as: :element_klass_id do |element|
+      element.element_klass&.id
+    end
+    expose :klass_label, as: :klass_label do |element|
+      element.element_klass&.label
+    end
+    expose :klass_name, as: :klass_name do |element|
+      element.element_klass&.name
+    end
+    expose :klass_icon, as: :klass_icon do |element|
+      element.element_klass&.icon_name
+    end
+  end
 end

data/lib/labimotion/apis/labimotion_api.rb

@@ -2,6 +2,7 @@
 module Labimotion
   class LabimotionAPI < Grape::API
     mount Labimotion::ConverterAPI
+    mount Labimotion::ExporterAPI
     mount Labimotion::GenericKlassAPI
     mount Labimotion::GenericElementAPI
     mount Labimotion::GenericDatasetAPI

data/lib/labimotion/helpers/dataset_helpers.rb

@@ -33,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/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/libs/dataset_builder.rb

@@ -29,7 +29,8 @@ module Labimotion
     end
 
     def self.find_dataset_klass(ols_term_id)
-      Labimotion::DatasetKlass.find_by(ols_term_id: ols_term_id)
+      result = Labimotion::TemplateMatcher.find_best_match(ols_term_id)
+      result[:template]
     end
 
     def self.create_dataset(container, klass)

data/lib/labimotion/libs/sample_association.rb

@@ -113,11 +113,12 @@ module Labimotion
           Labimotion::ElementsElement.find_or_create_by(parent_id: element.id, element_id: el.id)
           els << el.id
         end
-
       end
       if element.present?
-        es_list = Labimotion::ElementsSample.where(element_id: element.id).where.not(sample_id: sds)
-        ee_list = Labimotion::ElementsElement.where(parent_id: element.id).where.not(element_id: els&.flatten)
+        sds = sds.flatten.uniq
+        els = els.flatten.uniq
+        es_list = sds.present? ? Labimotion::ElementsSample.where(element_id: element.id).where.not(sample_id: sds) : Labimotion::ElementsSample.where(element_id: element.id)
+        ee_list = els.present? ? Labimotion::ElementsElement.where(parent_id: element.id).where.not(element_id: els) : Labimotion::ElementsElement.where(parent_id: element.id)
         es_list.destroy_all if es_list.present?
         ee_list.destroy_all if ee_list.present?
       end