labimotion 2.4.0.rc2 → 2.4.0.rc4

data/lib/labimotion/libs/data/datacite/labimotion_template.html.erb

@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resource xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://datacite.org/schema/kernel-4" xsi:schemaLocation="http://datacite.org/schema/kernel-4 https://schema.datacite.org/meta/kernel-4/metadata.xsd">
+  <identifier identifierType="DOI">https://dx.doi.org/<%= full_doi %></identifier>
+  <creators>
+    <% if creators.empty? %>
+    <creator>
+      <creatorName>(:unav)</creatorName>
+    </creator>
+    <% end %>
+    <% creators.each do |creator| %>
+    <creator>
+      <creatorName nameType="Personal"><%= creator['familyName'] %>, <%= creator['givenName'] %></creatorName>
+      <givenName><%= creator['givenName'] %></givenName>
+      <familyName><%= creator['familyName'] %></familyName>
+      <% if creator['orcid'].present? %>
+      <nameIdentifier schemeURI="https://orcid.org/" nameIdentifierScheme="ORCID"><%= creator['orcid'] %></nameIdentifier>
+      <% end %>
+      <% if creator['affiliation'].present? || creator['ror'].present? %>
+      <affiliation<% if creator['ror'].present? %> affiliationIdentifier="<%= creator['ror'] %>" affiliationIdentifierScheme="ROR" schemeURI="https://ror.org"<% end %>><%= creator['affiliation'] %></affiliation>
+      <% end %>
+    </creator>
+    <% end %>
+  </creators>
+  <titles>
+    <title xml:lang="en-US"><%= title %></title>
+  </titles>
+  <%= render_publisher(publisher_config) %>
+  <publicationYear><%= publication_year %></publicationYear>
+  <subjects>
+    <subject>Chemistry</subject>
+  </subjects>
+  <% if contributors.any? %>
+  <contributors>
+    <% contributors.each do |contributor| %>
+    <contributor contributorType="<%= contributor['contributorType'] %>">
+      <contributorName nameType="Personal"><%= contributor['familyName'] %>, <%= contributor['givenName'] %></contributorName>
+      <givenName><%= contributor['givenName'] %></givenName>
+      <familyName><%= contributor['familyName'] %></familyName>
+      <% if contributor['orcid'].present? %>
+      <nameIdentifier schemeURI="https://orcid.org/" nameIdentifierScheme="ORCID"><%= contributor['orcid'] %></nameIdentifier>
+      <% end %>
+      <% if contributor['affiliation'].present? || contributor['ror'].present? %>
+      <affiliation<% if contributor['ror'].present? %> affiliationIdentifier="<%= contributor['ror'] %>" affiliationIdentifierScheme="ROR" schemeURI="https://ror.org"<% end %>><%= contributor['affiliation'] %></affiliation>
+      <% end %>
+    </contributor>
+    <% end %>
+  </contributors>
+  <% end %>
+  <% if references.any? %>
+  <relatedIdentifiers>
+    <% references.each do |reference| %>
+    <relatedIdentifier relatedIdentifierType="DOI" relationType="References">https://dx.doi.org/<%= reference['doi'] %></relatedIdentifier>
+    <% end %>
+  </relatedIdentifiers>
+  <% end %>
+  <language>en</language>
+  <resourceType resourceTypeGeneral="Model"><%= resource_label %></resourceType>
+  <version><%= version %></version>
+  <rightsList>
+    <rights><%= license %></rights>
+  </rightsList>
+  <descriptions>
+    <% if description.present? %>
+    <description xml:lang="en-US" descriptionType="Abstract"><%= description %></description>
+    <% end %>
+  </descriptions>
+</resource>

data/lib/labimotion/libs/file_extractor.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'stringio'
+require 'timeout'
+require 'tempfile'
+require 'date'
+
+# Optional parsers — the feature degrades to filename-only if a gem is absent.
+begin
+  require 'pdf/reader'
+rescue LoadError
+  nil
+end
+begin
+  require 'roo'
+rescue LoadError
+  nil
+end
+
+module Labimotion
+  # FileExtractor turns an uploaded file (base64-encoded raw bytes + filename)
+  # into plain text usable as LLM context for the AI dataset-template feature.
+  #
+  # It NEVER raises into the caller. Any failure — missing gem, unsupported or
+  # oversized or corrupt file, parse error, timeout, out-of-memory — returns
+  # either '' or a short bracketed marker describing why, so the request keeps
+  # working with filename-only context.
+  module FileExtractor
+    TEXT_EXTS = %w[txt csv tsv md markdown json xml yml yaml].freeze
+    BINARY_EXTS = %w[pdf xlsx xlsm xls].freeze
+    ALLOWED_EXTS = (TEXT_EXTS + BINARY_EXTS).freeze
+
+    MAX_DECODED_BYTES = 15 * 1024 * 1024   # reject decoded payloads larger than this
+    MAX_UNCOMPRESSED = 80 * 1024 * 1024    # xlsx zip-bomb guard (sum of entry sizes)
+    MAX_OUT_CHARS = 8000                   # per-file extracted-text cap
+    MAX_PDF_PAGES = 50
+    MAX_SHEETS = 5
+    MAX_ROWS = 100
+    MAX_COLS = 30
+    MAX_CELL = 200
+    EXTRACT_TIMEOUT = 20                   # best-effort (cannot interrupt C-ext parsing)
+
+    # Magic bytes — forced to binary so start_with? never hits an
+    # Encoding::CompatibilityError against the ASCII-8BIT decoded bytes.
+    ZIP_MAGIC = "PK\x03\x04".b
+    OLE2_MAGIC = "\xD0\xCF\x11\xE0".b
+    PDF_MAGIC = '%PDF'.b
+
+    class << self
+      # @param filename [String] used for the extension whitelist + dispatch
+      # @param content_base64 [String] base64 of the raw file bytes (data-URL prefix tolerated)
+      # @return [String] extracted text, a '[...]' marker, or ''
+      def extract(filename, content_base64)
+        extract_bytes(filename, decode(content_base64))
+      end
+
+      # Same as #extract but for already-decoded RAW bytes (e.g. Attachment#read_file).
+      # Keeps every guard #extract has: extension whitelist, empty check,
+      # MAX_DECODED_BYTES cap, the extraction Timeout, output truncation and the
+      # four rescue clauses. NEVER raises into the caller.
+      #
+      # @param filename [String] used for the extension whitelist + dispatch
+      # @param bytes [String, nil] raw file bytes (any encoding; treated as binary)
+      # @return [String] extracted text, a '[...]' marker, or ''
+      def extract_bytes(filename, bytes)
+        ext = File.extname(filename.to_s).downcase.delete('.')
+        return '' unless ALLOWED_EXTS.include?(ext)
+
+        return '' if bytes.nil? || bytes.empty?
+        return '[file too large to extract]' if bytes.bytesize > MAX_DECODED_BYTES
+
+        truncate(Timeout.timeout(EXTRACT_TIMEOUT) { dispatch(ext, bytes) })
+      rescue Timeout::Error
+        '[extraction timed out]'
+      rescue NoMemoryError, SystemStackError => e
+        log(e)
+        '[file too complex to extract]'
+      rescue StandardError => e
+        log(e)
+        ''
+      end
+
+      private
+
+      def decode(content_base64)
+        str = content_base64.to_s.sub(/\Adata:[^;,]*;base64,/, '') # tolerate data-URL prefixes
+        return nil if str.strip.empty?
+
+        Base64.decode64(str)
+      end
+
+      # Dispatch by magic bytes first (robust against spoofed/missing extensions),
+      # falling back to the extension.
+      def dispatch(ext, bytes)
+        head = bytes[0, 8].to_s.b
+        if head.start_with?(ZIP_MAGIC) || %w[xlsx xlsm].include?(ext)
+          extract_xlsx(bytes)
+        elsif head.start_with?(OLE2_MAGIC) || ext == 'xls'
+          extract_xls(bytes)
+        elsif head.start_with?(PDF_MAGIC) || ext == 'pdf'
+          extract_pdf(bytes)
+        else
+          extract_text(bytes)
+        end
+      end
+
+      def extract_pdf(bytes)
+        return '[PDF support unavailable on this server]' unless defined?(PDF::Reader)
+
+        reader = PDF::Reader.new(StringIO.new(bytes))
+        buf = +''
+        reader.pages.first(MAX_PDF_PAGES).each do |page|
+          buf << page.text.to_s << "\n\n"
+          break if buf.length >= MAX_OUT_CHARS
+        end
+        text = buf.scrub('').strip
+        text.empty? ? '[no extractable text - likely a scanned/image PDF]' : text
+      rescue StandardError => e
+        log(e)
+        e.class.name.to_s.include?('Encrypted') ? '[encrypted PDF - no text extracted]' : ''
+      end
+
+      def extract_xlsx(bytes)
+        return '[Excel support unavailable on this server]' unless defined?(Roo::Excelx)
+        return '[Excel file too large to extract]' if xlsx_uncompressed_too_big?(bytes)
+
+        render_workbook(Roo::Excelx.new(StringIO.new(bytes)))
+      end
+
+      # Legacy OLE2 .xls needs the roo-xls gem (not bundled here) and a real path.
+      def extract_xls(bytes)
+        return '[legacy .xls not supported on this server]' unless defined?(Roo::Excel)
+
+        Tempfile.create(['labimotion-upload', '.xls']) do |f|
+          f.binmode
+          f.write(bytes)
+          f.flush
+          render_workbook(Roo::Spreadsheet.open(f.path))
+        end
+      end
+
+      def extract_text(bytes)
+        bytes.dup.force_encoding('UTF-8').scrub('')[0, MAX_OUT_CHARS].to_s
+      end
+
+      # Zip-bomb guard: sum the uncompressed entry sizes before roo inflates the
+      # archive. roo bundles rubyzip, so Zip is available when roo loaded.
+      def xlsx_uncompressed_too_big?(bytes)
+        return false unless defined?(Zip)
+
+        total = 0
+        Zip::File.open_buffer(StringIO.new(bytes)) do |zip|
+          zip.each do |entry|
+            total += entry.size.to_i
+            return true if total > MAX_UNCOMPRESSED
+          end
+        end
+        false
+      rescue StandardError
+        false # if we can't pre-inspect, let roo try (still bounded by caps + timeout)
+      end
+
+      # Render up to MAX_SHEETS sheets, each with a "## <name>" header and a
+      # capped, pipe-delimited row dump, under a shared output-char budget.
+      def render_workbook(book)
+        buf = +''
+        names = Array(book.sheets)
+        names.first(MAX_SHEETS).each do |name|
+          sheet = book.sheet(name)
+          next unless sheet.last_row # skip empty sheets
+
+          buf << "## #{name}\n"
+          last = [sheet.last_row, sheet.first_row + MAX_ROWS - 1].min
+          (sheet.first_row..last).each do |i|
+            line = +''
+            line << sheet.row(i).first(MAX_COLS).map { |c| fmt_cell(c) }.join(' | ') << "\n"
+            break if buf.length + line.length > MAX_OUT_CHARS
+
+            buf << line
+          end
+          buf << "[+#{sheet.last_row - last} more rows]\n" if sheet.last_row > last
+          break if buf.length >= MAX_OUT_CHARS
+        end
+        buf << "[+#{names.size - MAX_SHEETS} more sheets omitted]\n" if names.size > MAX_SHEETS
+        buf
+      end
+
+      # roo returns Date/Time/DateTime objects and nil for empty cells.
+      def fmt_cell(cell)
+        case cell
+        when nil then ''
+        when Date, Time, DateTime then cell.iso8601
+        else cell.to_s[0, MAX_CELL]
+        end
+      end
+
+      def truncate(str)
+        s = str.to_s
+        s.length > MAX_OUT_CHARS ? "#{s[0, MAX_OUT_CHARS]}\n…[truncated]" : s
+      end
+
+      def log(err)
+        Labimotion.log_exception(err) if Labimotion.respond_to?(:log_exception)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/labimotion/libs/owner_resolver.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# `index_by` below is an ActiveSupport core extension, not plain Ruby. A booted host always
+# has it, so the omission was invisible in production, but relying on the host to have loaded
+# it is luck rather than contract -- and in the gem's own spec process it made this file
+# depend on whether some other spec had required grape first.
+require 'active_support/core_ext/enumerable'
+
+module Labimotion
+  ## OwnerResolver
+  # Builds the `owners:` option the klass entities read, so rendering a grid of N templates
+  # costs one user query instead of N. Deleted users are included on purpose: a template whose
+  # author has left still has to name somebody, otherwise the grid can only say "unknown" and
+  # an administrator has nothing to act on.
+  class OwnerResolver
+    def self.map_for(klasses)
+      map_for_ids(Array(klasses).filter_map { |klass| klass.try(:created_by) })
+    end
+
+    # Same map, from bare user ids — what ShareResolver feeds it, where the ids come from
+    # owner share rows rather than a created_by column.
+    def self.map_for_ids(ids)
+      ids = Array(ids).compact.uniq
+      return {} if ids.empty?
+
+      user_scope.where(id: ids).index_by(&:id)
+    rescue StandardError => e
+      # Ownership is decoration on a list that must still render.
+      Labimotion.log_exception(e)
+      {}
+    end
+
+    # Single-user fallback for the call sites that ask for ownership without preloading a map.
+    # Same soft-delete scope and same "never break the caller" contract as `map_for`.
+    def self.find(user_id)
+      return nil if user_id.blank?
+
+      user_scope.find_by(id: user_id)
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      nil
+    end
+
+    # `with_deleted` comes from acts_as_paranoid, which the host's User model may not use.
+    def self.user_scope
+      ::User.respond_to?(:with_deleted) ? ::User.with_deleted : ::User
+    end
+    private_class_method :user_scope
+  end
+end

data/lib/labimotion/libs/ownership_audit.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# `constantize` and `underscore` below are ActiveSupport core extensions, not plain Ruby.
+# A booted host always has them, so the omission is invisible in production, but the gem's
+# own spec process does not load them on its own.
+require 'active_support/core_ext/string/inflections'
+require 'labimotion/constants'
+
+module Labimotion
+  ## OwnershipAudit
+  # Reports templates whose `created_by` may no longer name the person who wrote them.
+  #
+  # Why this exists: until the fix in this same change, `upload_klass` merged
+  # `created_by: current_user.id` into the attributes it handed to `validate_klass`, whose
+  # *update* branch then wrote them wholesale — so every re-import of an existing template
+  # reassigned its authorship to whoever re-imported it. The fix stops new damage; it cannot
+  # undo what already happened, and `created_by` is both what the Owner column displays and
+  # what per-template ownership will be seeded from.
+  #
+  # What it can and cannot tell you: a klass revision records `created_by` as the user who
+  # *released* that revision, not the one who created the klass. So a mismatch between a
+  # klass's `created_by` and its earliest revision's is a **signal** that authorship moved,
+  # not proof — a template legitimately first released by a colleague looks the same. This is
+  # a report for a human to read. It gates nothing, changes nothing, and writes nothing.
+  #
+  # Run it from the host:
+  #   bundle exec rails runner 'Labimotion::OwnershipAudit.report'
+  class OwnershipAudit
+    def self.report(io = $stdout)
+      findings = Labimotion::Constants::Klass::ALL.flat_map { |klass_name| findings_for(klass_name) }
+      io.puts(format_report(findings))
+      findings
+    end
+
+    def self.findings_for(klass_name)
+      model = "Labimotion::#{klass_name}".constantize
+      revision_model = "Labimotion::#{klass_name}esRevision".constantize
+      foreign_key = "#{klass_name.underscore}_id"
+
+      model.all.filter_map do |klass|
+        first_revision = revision_model.where(foreign_key => klass.id).order(:created_at).first
+        next if first_revision.nil?
+        next if first_revision.created_by.blank? || klass.created_by == first_revision.created_by
+
+        {
+          klass: klass_name,
+          id: klass.id,
+          label: klass.label,
+          created_by: klass.created_by,
+          first_release_by: first_revision.created_by,
+          first_released_at: first_revision.created_at
+        }
+      end
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+      []
+    end
+
+    def self.format_report(findings)
+      lines = ["Labimotion ownership audit — #{findings.size} template(s) to look at"]
+      lines << 'created_by differs from the user who released the earliest revision. ' \
+               'Expected for templates a colleague first released; suspicious for the rest.'
+      lines << ''
+      findings.each do |f|
+        lines << "#{f[:klass].ljust(13)} ##{f[:id].to_s.ljust(5)} " \
+                 "#{f[:label].to_s[0, 40].ljust(40)} created_by=#{f[:created_by]} " \
+                 "first_release_by=#{f[:first_release_by]} (#{f[:first_released_at]})"
+      end
+      lines.join("\n")
+    end
+    private_class_method :format_report
+  end
+end

data/lib/labimotion/libs/share_notifier.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Courtesy notifications for share events (template-sharing.md §7), moved in
+  # from the host's Chemotion::TemplateShareAPI (chem-generic-ui#1040): the gem
+  # writes the share rows, so the gem announces them, and the two-call dance the
+  # Designer used to do (write to the gem, then call the host back to notify)
+  # collapses into the write.
+  #
+  # These messages buy awareness *outside* the Designer only — the toast in the
+  # main ELN. klass_shares is the record and the Designer reads the rows; it
+  # never reads or acks a Message. Nothing here may therefore fail a share:
+  # every public method rescues to nil, and an undeliverable notification is a
+  # notification not sent, never an error. Callers fire after the successful
+  # write and ignore the return value.
+  #
+  # The host models are reached by their bare names and only if they exist:
+  # a host without Message/Channel machinery (or one that has not run the
+  # channel migration) simply sends nothing. The channel is looked up by its
+  # literal subject — referencing Channel::TEMPLATE_SHARE_NOTIFICATION would
+  # raise on hosts whose Channel model predates the constant.
+  module ShareNotifier
+    # Must match the subject the host ELN's channel migration seeds
+    # (add_template_share_notification_channel; channel_type 8, the targeted
+    # per-user delivery branch of generate_notifications).
+    CHANNEL_SUBJECT = 'Template Share Notification'
+
+    # Fired for level changes too — the grant endpoint is an upsert and cannot
+    # tell a fresh share from a level change, so "granted you X access" stays
+    # honest for both.
+    def self.grant(klass:, actor:, user_ids:, level:)
+      label = template_label(klass)
+      ping(
+        actor: actor, user_ids: user_ids,
+        text: "#{actor.name} granted you #{level} access to the template '#{label}'."
+      )
+    rescue StandardError => e
+      Labimotion.log_exception(e, actor)
+      nil
+    end
+
+    def self.transfer(klass:, actor:, user_id:)
+      label = template_label(klass)
+      ping(
+        actor: actor, user_ids: [user_id],
+        text: "#{actor.name} transferred ownership of the template '#{label}' to you."
+      )
+    rescue StandardError => e
+      Labimotion.log_exception(e, actor)
+      nil
+    end
+
+    # The owner to ask: the klass_shares owner row, falling back to the
+    # immutable created_by for an owner-less template. A blank owner matches no
+    # user and channel_type-8 fan-out reaches Persons only, so an Admin owner
+    # gets no toast — they learn about the request when they next open the
+    # Designer, where the rows are the truth. The caller gates on `created`:
+    # the unique index dedupes rows, not messages, so only the ask that wrote
+    # the row earns a ping.
+    def self.request(klass:, actor:)
+      owner_id = Labimotion::KlassShare.owner_row_for(klass)&.shared_with_id ||
+                 klass.created_by
+      return if owner_id.nil?
+
+      label = template_label(klass)
+      ping(
+        actor: actor, user_ids: [owner_id],
+        text: "#{actor.name} asks for access to your template '#{label}'. " \
+              'You can grant it from the Share dialog in the Designer.'
+      )
+    rescue StandardError => e
+      Labimotion.log_exception(e, actor)
+      nil
+    end
+
+    # Plain Ruby, no ActiveSupport (`presence`/`try`): the host models are
+    # optional here, so the module must not assume the host's core extensions
+    # either — with them absent, a notification would silently never send.
+    def self.template_label(klass)
+      read_name(klass, :label) || read_name(klass, :name) || "##{klass.id}"
+    end
+
+    def self.read_name(klass, attribute)
+      return nil unless klass.respond_to?(attribute)
+
+      value = klass.public_send(attribute).to_s
+      value.strip.empty? ? nil : value
+    end
+
+    def self.ping(actor:, user_ids:, text:)
+      return unless defined?(::Message) && defined?(::Channel)
+
+      # Persons only (the fan-out inserts notifications for Persons alone), and
+      # never the actor: granting yourself a toast about your own click is
+      # noise, and a self-transfer is a no-op to announce.
+      recipients = ::User.where(type: 'Person', id: user_ids).ids - [actor.id]
+      return if recipients.empty?
+
+      channel = ::Channel.find_by(subject: CHANNEL_SUBJECT)
+      return if channel.nil?
+
+      ::Message.create_msg_notification(
+        channel_id: channel.id,
+        # The level rides inside message_content: create_msg_notification uses
+        # the content verbatim on this path, so a bare level: kwarg would be
+        # dropped and the toast would fall back to warning styling.
+        message_content: { data: text, level: 'info' },
+        message_from: actor.id,
+        message_to: recipients
+      )
+    end
+    private_class_method :ping, :template_label, :read_name
+  end
+end