labimotion 2.0.0 → 2.1.0.rc11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c1fa1527f921643836476d930d66fedc973e06e2a6300d9e100e2852fc96168
-  data.tar.gz: 4ccc2fe165c170aa98fba5db9d63c576ed997e9650e54da439b1b295da65c816
+  metadata.gz: b62609cc21d0cca64e84a149f6d81af0656cc3e95d5086e75f0f3b6baca27472
+  data.tar.gz: be1fa743e3c305cc25130deed4fe4f5bbe567fa0b07e93a9429412c981c08c64
 SHA512:
-  metadata.gz: 39915628df304676e86ad4e601d6776e994eb5007cc2f857c48b64498c24dba596d3ae1a46136b1d9c909dc3620724c10f0605682ba34224430c5405324d9076
-  data.tar.gz: fae1a472384cd8ba2c7e93c647399add301ed35e4404038382f451c6b2f2c7644331004c67cba91e76872e844b334fb8041e4a1dbf682dc6644010d9fd7630fe
+  metadata.gz: b5dafb066cf6137a934e2dfb67d532c7edbf84c4dd46f076d4f9055d4d23ae61cb0568d65a99c3ee34ded0f658a4daf9ec1cffad8cffa9f25b089774f5a3c424
+  data.tar.gz: d085a36adef5d13a3dbfa97c4979c83afea948c17bff059c9050b88043ab0b927b9c9dea693e7057185669e632baba2be392739f535b97459e8d91626d909507

data/lib/labimotion/apis/exporter_api.rb

@@ -0,0 +1,271 @@
+# 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 base columns for smiles and short_label
+        if sub_field['type'] == Labimotion::FieldType::DRAG_SAMPLE
+          %w[smiles short_label].each do |base_header|
+            headers << base_header
+            expanded_sub_fields << {
+              'id' => sub_field['id'],
+              'type' => sub_field['type'],
+              'sub_header' => base_header,
+              'original' => sub_field,
+              'is_base_column' => true
+            }
+          end
+        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
 
@@ -11,19 +12,38 @@ 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
 
@@ -48,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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'cgi'
 require 'labimotion/conf'
 require 'labimotion/libs/export_element'
 
@@ -59,6 +60,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
@@ -79,7 +139,7 @@ module Labimotion
           env['api.format'] = :binary
           content_type 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
           el_filename = export.res_name
-          filename = URI.escape(el_filename)
+          filename = CGI.escape(el_filename)
           # header['Content-Disposition'] = "attachment; filename=abc.docx"
           header('Content-Disposition', "attachment; filename=\"#{filename}\"")
 
@@ -188,7 +248,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 +281,27 @@ 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'
+          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]
+        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 +347,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 +382,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)
@@ -445,4 +526,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/generic_klass_api.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require 'cgi'
 require 'labimotion/version'
 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
@@ -19,7 +21,7 @@ module Labimotion
           entity.update_columns(identifier: SecureRandom.uuid) if entity&.identifier.nil?
           env['api.format'] = :binary
           content_type('application/json')
-          filename = URI.escape("LabIMotion_#{params[:klass]}_#{entity.label}-#{Time.new.strftime("%Y%m%d%H%M%S")}.json")
+          filename = CGI.escape("LabIMotion_#{params[:klass]}_#{entity.label}-#{Time.new.strftime("%Y%m%d%H%M%S")}.json")
           # header['Content-Disposition'] = "attachment; filename=abc.docx"
           header('Content-Disposition', "attachment; filename=\"#{filename}\"")
           "Labimotion::#{params[:klass]}Entity".constantize.represent(entity)
@@ -30,6 +32,44 @@ module Labimotion
         end
       end
 
+      namespace :de_activate do
+        desc 'activate or deactivate Generic Klass'
+        params do
+          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+          requires :id, type: Integer, desc: 'Klass ID'
+          requires :is_active, type: Boolean, desc: 'Active or Inactive Klass'
+        end
+        after_validation do
+          authenticate_admin!(params[:klass].gsub(/(Klass)/, 's').downcase)
+          fetch_klass(params[:klass], params[:id])
+        end
+        post do
+          updated_klass = deactivate_klass(params)
+          entity_class = "Labimotion::#{params[:klass]}Entity".constantize
+          serialized_data = entity_class.represent(updated_klass)
+          { mc: 'ss00', data: serialized_data }
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          { mc: 'se00', msg: e.message, data: {} }
+        end
+      end
+
+      namespace :fetch do
+        desc 'fetch Generic Klass by id'
+        params do
+          requires :id, type: Integer, desc: 'Klass ID'
+          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+        end
+        get do
+          klass_obj = fetch_klass(params[:klass], params[:id])
+          entity_class = "Labimotion::#{params[:klass]}Entity".constantize
+          serialized_data = entity_class.represent(klass_obj)
+          { mc: 'ss00', data: serialized_data }
+        rescue StandardError => e
+          Labimotion.log_exception(e, current_user)
+          { mc: 'se00', msg: e.message, data: {} }
+        end
+      end
     end
   end
-end
+end

data/lib/labimotion/apis/labimotion_api.rb

@@ -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/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