labimotion 2.3.0 → 2.4.0.rc11

data/lib/labimotion/helpers/element_helpers.rb

@@ -3,11 +3,16 @@
 require 'grape'
 require 'labimotion/conf'
 require 'labimotion/utils/utils'
+require 'labimotion/helpers/cover_image_helpers'
 # require 'labimotion/models/element_klass'
 module Labimotion
   ## ElementHelpers
   module ElementHelpers
     extend Grape::API::Helpers
+    # the element save validates metadata.cover_images up front through
+    # prepare_element_metadata — carry the dependency instead of relying on
+    # both modules being mounted on the same Grape endpoint
+    include Labimotion::CoverImageHelpers
 
     def klass_list(is_generic_only)
       if is_generic_only == true
@@ -31,7 +36,13 @@ module Labimotion
       attributes[:properties_release] = attributes[:properties_template]
       attributes[:created_by] = current_user.id
 
-      new_klass = Labimotion::ElementKlass.create!(attributes)
+      # The owner row shares the create's transaction: a klass committed without it is
+      # owner-less, which falls open to the legacy designer-wide gate.
+      new_klass = Labimotion::ElementKlass.transaction do
+        Labimotion::ElementKlass.create!(attributes).tap do |klz|
+          Labimotion::KlassShare.seed_owner!(klz, current_user.id)
+        end
+      end
       new_klass.reload
       new_klass.create_klasses_revision(current_user)
       klass_names_file = Labimotion::KLASSES_JSON # Rails.root.join('app/packs/klasses.json')
@@ -43,6 +54,249 @@ module Labimotion
       raise e
     end
 
+    # Create a new (inactive) element klass whose properties template is
+    # generated by an LLM from a user-provided name/label plus optional
+    # description, reference links and uploaded files. The admin reviews/edits
+    # the generated template in the designer and activates it (human-in-the-loop).
+    def create_ai_element_klass(params, current_user)
+      name = params[:name]
+      label = params[:label]
+      if Labimotion::ElementKlass.find_by(name: name).present?
+        return { status: 'error', message: "An element named [#{name}] already exists." }
+      end
+
+      if Array(params[:files]).size > Labimotion::AiTemplate::MAX_FILES
+        return { status: 'error', message: "Too many files (max #{Labimotion::AiTemplate::MAX_FILES})." }
+      end
+
+      overrides = ai_user_overrides(current_user)
+      ai = Labimotion::AiTemplate.generate(
+        kind: 'element',
+        subject: "#{params[:label]} (#{params[:name]})",
+        desc: params[:desc],
+        cols: params[:cols],
+        references: params[:references],
+        files: params[:files],
+        **overrides
+      )
+
+      uuid = SecureRandom.uuid
+      # property-base schema requires pkg, uuid, klass, layers, version, identifier.
+      properties_template = {
+        'uuid' => uuid,
+        'klass' => 'ElementKlass',
+        'pkg' => Labimotion::Utils.pkg(nil),
+        'version' => '1.0.0',
+        'identifier' => uuid,
+        'layers' => ai['layers'],
+        'select_options' => ai['select_options'],
+        'metadata' => ai['metadata']
+      }
+      attributes = {
+        'name' => name,
+        'label' => label,
+        'klass_prefix' => params[:klass_prefix],
+        'icon_name' => params[:icon_name],
+        'desc' => params[:desc].presence || ai['label'].presence,
+        'is_active' => false,
+        'uuid' => uuid,
+        'released_at' => DateTime.now,
+        'properties_template' => properties_template,
+        'properties_release' => properties_template,
+        'created_by' => current_user.id
+      }
+
+      # Same as the non-AI create beside it: the owner row shares the create's
+      # transaction, because a klass committed without one is owner-less and
+      # falls OPEN to the legacy designer-wide gate — every designer of the
+      # family could then edit, release and delete it, while its creator holds
+      # no special standing at all. seed_owner! rescues only RecordNotUnique and
+      # RecordInvalid, so any other failure has to take the klass down with it;
+      # this helper turns every StandardError into { status: 'error' }, and
+      # without the transaction the caller would be told the create failed while
+      # an unowned template silently persisted.
+      new_klass = Labimotion::ElementKlass.transaction do
+        Labimotion::ElementKlass.create!(attributes).tap do |klz|
+          Labimotion::KlassShare.seed_owner!(klz, current_user.id)
+        end
+      end
+      new_klass.reload
+      new_klass.create_klasses_revision(current_user)
+      klass_names_file = Labimotion::KLASSES_JSON # Rails.root.join('app/packs/klasses.json')
+      klasses = Labimotion::ElementKlass.where(is_active: true)&.pluck(:name) || []
+      File.write(klass_names_file, klasses)
+      # `record` is the row itself. The background job that calls this needs the
+      # template, not a sentence about it, to link the notification back to it.
+      { status: 'success', record: new_klass,
+        message: "The AI element template [#{label}] has been created as inactive. Review and activate it in the designer." }
+    rescue StandardError => e
+      Labimotion.log_exception(e, current_user)
+      { status: 'error', message: e.message }
+    end
+
+    # AI auto-fill of a generic element instance's DATA VALUES from a document
+    # (an existing attachment, an analysis, or freshly uploaded files). Reads the
+    # source text, asks the LLM to extract values for the element's OWN template
+    # fields, validates them, and returns them for the client to merge into the
+    # working copy for human review. Nothing is persisted here.
+    #
+    # Authorization: the caller must be able to READ the element, and the source
+    # must BELONG to that element (see the ownership checks below) — this endpoint
+    # reads files by id, so it must never read an Attachment/Container the user
+    # does not already have access to through this element.
+    def ai_fill_element_data(params, current_user)
+      element = Labimotion::Element.find(params[:element_id])
+      error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, element).read?
+
+      text = ai_fill_source_text(element, params)
+      overrides = ai_user_overrides(current_user)
+      ai = Labimotion::AiTemplate.fill(
+        properties: ai_fill_properties(element),
+        context_text: text,
+        instructions: ai_fill_instructions(element),
+        **overrides
+      )
+      { status: 'success', values: ai['values'], summary: ai['summary'], usage: ai['usage'], model: ai['model'] }
+    rescue StandardError => e
+      Labimotion.log_exception(e, current_user)
+      { status: 'error', message: e.message }
+    end
+
+    # The element's properties, with the select_options its own fields point at.
+    #
+    # An element instance never stores select_options: create and update both
+    # delete the key (see create_element/update_element below), because the
+    # options belong to the template, not to the instance. The fill prompt lists
+    # a select's allowed options so the model can pick one, and reads them out
+    # of the properties it is handed — so passing element.properties straight
+    # through offered the model an EMPTY list for every select and select-multi
+    # field. Nothing to choose from, so those fields came back unfilled, which
+    # reads as the AI having ignored them.
+    #
+    # properties_release, not the klass's current properties_template: it is the
+    # release this element was actually built against, so its option keys are the
+    # ones the element's fields reference and the ones the form will accept back.
+    # Same source the UI and the exporter read for this element.
+    def ai_fill_properties(element)
+      props = element.properties
+      return props unless props.is_a?(Hash)
+      return props if props['select_options'].present?
+
+      release = element.properties_release
+      options = release.is_a?(Hash) ? release['select_options'] : nil
+      return props if options.blank?
+
+      props.merge('select_options' => options)
+    end
+
+    # The template's own auto-fill guidance, from Template settings in the designer.
+    # Read from the KLASS rather than the element's copied properties, so editing it
+    # takes effect on elements that already exist instead of only on new ones.
+    def ai_fill_instructions(element)
+      settings = element.element_klass&.settings
+      return nil unless settings.is_a?(Hash)
+
+      settings[Labimotion::Constants::KlassSetting::AI_FILL_PROMPT].presence
+    end
+
+    # Resolve the requested source into plain text, enforcing ownership first.
+    def ai_fill_source_text(element, params)
+      case params[:source]
+      when 'attachment'
+        ai_fill_attachment_text(element, params[:attachment_id])
+      when 'analysis'
+        ai_fill_analysis_text(element, params[:container_id])
+      when 'upload'
+        ai_fill_upload_text(params[:files])
+      when 'text'
+        ai_fill_pasted_text(params[:text])
+      else
+        error!('400 Bad Request', 400)
+      end
+    end
+
+    # The attachment must be one of the element's own attachments OR an attachment
+    # of one of the element's analysis DATASET containers. Only then is it read.
+    def ai_fill_attachment_text(element, attachment_id)
+      error!('404 Not Found', 404) if attachment_id.nil?
+      error!('404 Not Found', 404) unless ai_fill_element_attachment_ids(element).include?(attachment_id.to_i)
+
+      att = Attachment.find(attachment_id)
+      Labimotion::FileExtractor.extract_bytes(att.filename, att.read_file)
+    end
+
+    # The container id must be one of the element's own analysis containers. Then
+    # concatenate the extracted text of every attachment on that analysis's dataset
+    # children, each prefixed "### <filename>", with the analysis name/description
+    # prepended as context. Cap at AiTemplate::MAX_FILES; skip unreadable files.
+    def ai_fill_analysis_text(element, container_id)
+      error!('404 Not Found', 404) if container_id.nil?
+      analysis = element.analyses.detect { |c| c.id == container_id.to_i }
+      error!('404 Not Found', 404) if analysis.nil?
+
+      parts = []
+      context = [analysis.name.presence, analysis.description.presence].compact.join(' — ')
+      parts << "Analysis: #{context}" if context.present?
+
+      ai_fill_analysis_attachments(analysis).first(Labimotion::AiTemplate::MAX_FILES).each do |att|
+        content = ai_fill_extract_attachment(att)
+        next if content.to_s.strip.empty?
+
+        parts << "### #{att.filename}\n#{content}"
+      end
+      parts.join("\n\n")
+    end
+
+    def ai_fill_upload_text(files)
+      parts = Array(files).first(Labimotion::AiTemplate::MAX_FILES).map do |file|
+        name = file[:filename] || file['filename']
+        next if name.blank?
+
+        content = Labimotion::FileExtractor.extract(name, file[:content_base64] || file['content_base64'])
+        next if content.to_s.strip.empty?
+
+        "### #{name}\n#{content}"
+      end.compact
+      parts.join("\n\n")
+    end
+
+    # Text pasted straight into the dialog. Capped like an extracted file so a
+    # very long paste cannot blow the model's context or the request budget —
+    # the same MAX_FILE_CHARS the file path is held to.
+    def ai_fill_pasted_text(text)
+      body = text.to_s.strip
+      error!('400 Bad Request', 400) if body.empty?
+
+      body[0, Labimotion::AiTemplate::MAX_FILE_CHARS].to_s
+    end
+
+    # Ids of attachments this element may expose to the AI fill: its own
+    # attachments plus the attachments of its analysis dataset containers.
+    def ai_fill_element_attachment_ids(element)
+      own = element.attachments.pluck(:id)
+      dataset_ids = ai_fill_dataset_containers(element).map(&:id)
+      dataset_att = dataset_ids.empty? ? [] : Attachment.where(attachable_type: 'Container', attachable_id: dataset_ids).pluck(:id)
+      (own + dataset_att).uniq
+    end
+
+    # Dataset containers under all of the element's analysis containers.
+    def ai_fill_dataset_containers(element)
+      element.analyses.flat_map { |analysis| analysis.children.where(container_type: 'dataset').to_a }
+    end
+
+    def ai_fill_analysis_attachments(analysis)
+      analysis.children.where(container_type: 'dataset').flat_map do |dataset|
+        Attachment.where(attachable_type: 'Container', attachable_id: dataset.id).to_a
+      end
+    end
+
+    def ai_fill_extract_attachment(att)
+      Labimotion::FileExtractor.extract_bytes(att.filename, att.read_file)
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      nil
+    end
+
     def update_element_klass(current_user, params)
       place = params[:place] || 100
       begin
@@ -51,6 +305,7 @@ module Labimotion
         place = 100
       end
       klass = Labimotion::ElementKlass.find(params[:id])
+      authorize_klass!(klass, :write)
       klass.label = params[:label] if params[:label].present?
       klass.klass_prefix = params[:klass_prefix] if params[:klass_prefix].present?
       klass.icon_name = params[:icon_name] if params[:icon_name].present?
@@ -82,7 +337,7 @@ module Labimotion
         klass_uuid: klass[:uuid],
         properties: properties,
         properties_release: params[:properties_release],
-        metadata: params[:metadata] || {},
+        metadata: prepare_element_metadata({}, params[:metadata]),
         created_by: current_user.id
       }
       element = Labimotion::Element.new(attributes)
@@ -110,6 +365,11 @@ module Labimotion
 
     def update_element_by_id(current_user, params)
       element = Labimotion::Element.find(params[:id])
+      # Validated up front, before the container/sample-association writes run:
+      # a rejected cover selection must fail the request whole, not leave a
+      # half-applied datamodel behind. error! throws rather than raises, so it
+      # escapes this method's rescue-and-log and reaches the client as a 422.
+      metadata = prepare_element_metadata(element.metadata, params[:metadata])
       update_datamodel(params[:container], current_user)
       properties = update_sample_association(params[:properties], current_user, element)
       params.delete(:container)
@@ -118,7 +378,6 @@ module Labimotion
       params.delete(:user_labels)
       attributes = declared(params.except(:segments), include_missing: false)
       properties['pkg'] = Labimotion::Utils.pkg(properties['pkg'])
-      metadata = params[:metadata] || element.metadata || {}
       if element.klass_uuid != properties['klass_uuid'] || element.properties != properties || element.name != params[:name] || element.metadata != metadata
         properties['klass'] = 'Element'
         uuid = SecureRandom.uuid
@@ -305,12 +564,25 @@ module Labimotion
     end
 
     def validate_klass(attributes)
-      element_klass = Labimotion::ElementKlass.find_by(identifier: attributes['identifier'])
+      # Guarded on presence like the segment path: a blank identifier must mean "create",
+      # never `find_by(identifier: nil)` — that would match an arbitrary legacy row whose
+      # identifier is NULL and upgrade an unrelated template.
+      element_klass = Labimotion::ElementKlass.find_by(identifier: attributes['identifier']) if attributes['identifier'].present?
       if element_klass.present?
         if element_klass['uuid'] == attributes['uuid'] && element_klass['version'] == attributes['version']
           return { status: 'success', message: "This element: #{attributes['name']} has the latest version!" }
         else
-          element_klass.update!(attributes)
+          # Upgrading an existing template bumps its version and cuts a revision — publishing,
+          # which is what :release means, so it is owner-only. The gate has to live here, not
+          # in after_validation: which branch applies is unknown until this identifier lookup
+          # has run. error! throws rather than raises, so it escapes this method's rescue.
+          authorize_klass!(element_klass, :release)
+          # And it must not reassign authorship. `upload_klass` merges
+          # `created_by: current_user.id` into the attributes unconditionally
+          # (generic_element_api.rb), so without this the importer silently becomes the author
+          # of a template somebody else wrote — and that column is what the Owner column shows
+          # and what per-template ownership is seeded from.
+          element_klass.update!(attributes.except('created_by', :created_by))
           element_klass.create_klasses_revision(current_user)
           return { status: 'success', message: "This element: [#{attributes['name']}] has been upgraded to the version: #{attributes['version']}!" }
         end
@@ -320,7 +592,11 @@ module Labimotion
           return { status: 'error', message: "The name [#{attributes['name']}] is already in use." }
         else
           attributes['created_by'] = current_user.id
-          element_klass = Labimotion::ElementKlass.create!(attributes)
+          element_klass = Labimotion::ElementKlass.transaction do
+            Labimotion::ElementKlass.create!(attributes).tap do |klz|
+              Labimotion::KlassShare.seed_owner!(klz, current_user.id)
+            end
+          end
           element_klass.create_klasses_revision(current_user)
           return { status: 'success', message: "The element: #{attributes['name']} has been created using version: #{attributes['version']}!" }
         end

data/lib/labimotion/helpers/exporter_helpers.rb

@@ -13,9 +13,13 @@ module Labimotion
       col_name
     end
 
-    # Check if field type should be expanded (DRAG_SAMPLE or DRAG_MOLECULE)
+    # Check if field type should be expanded (DRAG_SAMPLE, DRAG_MOLECULE or DRAG_ELEMENT)
     def expandable_field?(field_type)
-      [Labimotion::FieldType::DRAG_SAMPLE, Labimotion::FieldType::DRAG_MOLECULE].include?(field_type)
+      [
+        Labimotion::FieldType::DRAG_SAMPLE,
+        Labimotion::FieldType::DRAG_MOLECULE,
+        Labimotion::FieldType::DRAG_ELEMENT
+      ].include?(field_type)
     end
 
     # Generate sanitized filename for export
@@ -34,6 +38,8 @@ module Labimotion
       case sub_field['type']
       when Labimotion::FieldType::DRAG_SAMPLE, Labimotion::FieldType::DRAG_MOLECULE
         format_drag_field_cell(sub_val, sub_field)
+      when Labimotion::FieldType::DRAG_ELEMENT
+        format_element_cell(sub_val, sub_field)
       when Labimotion::FieldType::SELECT
         format_select_cell(sub_val, sub_field)
       when Labimotion::FieldType::SYSTEM_DEFINED
@@ -95,6 +101,15 @@ module Labimotion
       end
     end
 
+    # Format drag_element cell — a linked element has no structure image,
+    # so the short label is the cell text
+    def format_element_cell(sub_val, sub_field)
+      val = sub_val[sub_field['id']]['value'] || {}
+      return '' if val.blank?
+
+      val['el_label'].present? ? val['el_label'].to_s : val['el_name'].to_s
+    end
+
     # Format select cell
     def format_select_cell(sub_val, sub_field)
       sub_val[sub_field['id']]['value'].to_s