labimotion 2.2.0.rc22 → 2.3.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c79a031d59f881b26d04e1acb6863bff76a6164e096068268d7495042d8db0f0
-  data.tar.gz: 3d84dc19e636a8c57734675e41d58ef16bb821e7d7be34be2cbe7b3196a3b804
+  metadata.gz: ed76c84363276af955102072d3491035f014dedb9fcdc835b4ec9c2e9ba199ee
+  data.tar.gz: 8a5e3a1d1c5ac1fb497d278c1f9a3237dfc0f93271729e05c602339879d6a204
 SHA512:
-  metadata.gz: 4ad9ee1d24b63e2ebdc8a6bf6ca338fe3170644c63bc50cafcd89a660250fef0747375617b394a8174644ead7461f2dcc1d81fa4095e7365e11b07517781af00
-  data.tar.gz: 103e68dc679f80f3a214946361dc70ad5c1204336f567d17aaae4a9aa32298e56c23f4af4f545f07e27c9cdc8ccaea7bcc00e4978918af0b9d5f9baba6188785
+  metadata.gz: 1d9d033f42be38117263ab30d502a3eafa5f9fa3b983f834dd1b1e14ab55537c91fafafd5b1643a6d3e2ea5e2e2ec17a8a072220cef56a4b80a34deca8f6600c
+  data.tar.gz: 926082586397c99e47f634733d2e258b463a9340809e45d5a0d4a788ff508c0335279e80baabef1f89b851691777d764b8657b6825b40a420e962dab4c6e6f36

data/lib/labimotion/apis/generic_element_api.rb

@@ -432,7 +432,6 @@ module Labimotion
       desc 'Return serialized elements of current user'
       params do
         optional :collection_id, type: Integer, desc: 'Collection id'
-        optional :sync_collection_id, type: Integer, desc: 'SyncCollectionsUser id'
         optional :el_type, type: String, desc: 'element klass name'
         optional :from_date, type: Integer, desc: 'created_date from in ms'
         optional :to_date, type: Integer, desc: 'created_date to in ms'

data/lib/labimotion/apis/labimotion_doi_api.rb

@@ -7,10 +7,6 @@ module Labimotion
     # rubocop:disable Metrics/BlockLength
     # Grape route and helper DSL blocks are necessarily large.
     KLASS_TYPES = Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE.keys.freeze
-    # Publication fields exposed on the public (anonymous) DOI endpoints.
-    # `contributor` (singular) is kept for DOIs released before contributors
-    # became a list — their snapshot still carries it.
-    PUBLIC_PUBLICATION_KEYS = %w[title description authors contributors contributor references license].freeze
 
     helpers do
       def resolve_klass!(type, id)
@@ -45,36 +41,25 @@ module Labimotion
         )
       end
 
-      # Public, read-only view of one released DOI version, carrying the
-      # publication metadata that version was released with.
-      def released_doi_version(record, doi)
+      # Public, read-only view of one released DOI version.
+      def released_doi_version(doi)
         full = doi.full_doi
         {
           doi: full,
           doi_url: "https://dx.doi.org/#{full}",
           version: ::Doi.labimotion_doi_version(doi),
-          minted_at: doi.minted_at,
-          publication: released_publication(record, doi)
+          minted_at: doi.minted_at
         }
       end
 
-      # The snapshot taken when this version was released. DOIs released before
-      # snapshots were kept have none, and fall back to the template's current
-      # publication — the best available answer for them.
-      def released_publication(record, doi)
-        publication = ::Doi.labimotion_doi_publication(doi).presence ||
-                      (record.properties_template || {})['publication']
-        publication.is_a?(Hash) ? publication.slice(*PUBLIC_PUBLICATION_KEYS) : {}
-      end
-
       # Public payload for a template that has at least one released DOI: the
       # latest released DOI promoted to the top level, plus its publication
-      # metadata, hub deep-link and every released version. Each version brings
-      # its own publication, so the top-level one is the latest release's rather
-      # than the template's work-in-progress. `record_id` matches the hub grid's
-      # row id (identifier || uuid) so the frontend can merge it.
+      # metadata, hub deep-link and every released version. `record_id` matches
+      # the hub grid's row id (identifier || uuid) so the frontend can merge it.
       def released_template_doi(record, dois)
-        versions = dois.sort_by(&:id).map { |doi| released_doi_version(record, doi) }
+        versions = dois.sort_by(&:id).map { |doi| released_doi_version(doi) }
+        publication = (record.properties_template || {})['publication']
+        publication = publication.is_a?(Hash) ? publication.slice('title', 'description', 'authors', 'license') : {}
         versions.last.merge(
           record_id: record.try(:identifier).presence || record.try(:uuid).presence || record.id,
           identifier: record.try(:identifier),
@@ -83,6 +68,7 @@ module Labimotion
           template_version: record.try(:version),
           next_doi_version: ::Doi.labimotion_version_segment(record),
           template_url: Labimotion::TemplateDoiHelpers.template_url(record),
+          publication: publication,
           versions: versions
         )
       end
@@ -139,7 +125,7 @@ module Labimotion
                 version: ::Doi.labimotion_doi_version(doi),
                 full_doi: doi.full_doi,
                 minted: doi.minted == true,
-                xml: Labimotion::BuildTemplateDoiXml.new(record, doi).call
+                xml: Labimotion::BuildTemplateDoiXml.new(record, doi, current_user).call
               }
             end
             { versions: versions }

data/lib/labimotion/apis/labimotion_template_browse_api.rb

@@ -9,10 +9,6 @@ module Labimotion
   class LabimotionTemplateBrowseAPI < Grape::API
     KLASS_BY_TYPE = Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE
     KLASS_TYPES = KLASS_BY_TYPE.keys.freeze
-    # Publication fields exposed alongside a template / its released DOIs.
-    # `contributor` (singular) is kept for DOIs released before contributors
-    # became a list — their snapshot still carries it.
-    PUBLICATION_KEYS = %w[title description authors contributors contributor references license].freeze
     # type => [revision model, foreign key to the klass]
     REVISION_BY_TYPE = {
       'element' => [::Labimotion::ElementKlassesRevision, :element_klass_id],
@@ -80,14 +76,7 @@ module Labimotion
       # The template's DOI publication metadata (shown alongside the DOI).
       def template_publication(record)
         pub = (record.properties_template || {})['publication']
-        pub.is_a?(Hash) ? pub.slice(*PUBLICATION_KEYS) : {}
-      end
-
-      # The publication a released DOI was published with. Falls back to the
-      # template's current metadata for DOIs released before snapshots were kept.
-      def released_publication(record, doi)
-        pub = ::Doi.labimotion_doi_publication(doi)
-        pub.is_a?(Hash) && pub.any? ? pub.slice(*PUBLICATION_KEYS) : template_publication(record)
+        pub.is_a?(Hash) ? pub.slice('title', 'description', 'authors', 'license') : {}
       end
 
       # Released (minted) DOIs of the template, each tagged with its DOI version
@@ -99,7 +88,6 @@ module Labimotion
           full = doi.full_doi
           { version: ::Doi.labimotion_doi_version(doi), doi: full,
             doi_url: "https://dx.doi.org/#{full}", minted_at: doi.minted_at,
-            publication: released_publication(record, doi),
             xml: Labimotion::BuildTemplateDoiXml.new(record, doi).call }
         end
       end

data/lib/labimotion/helpers/element_helpers.rb

@@ -215,7 +215,7 @@ module Labimotion
         layer, field = params[:sort_column].split('.')
 
         element_klass = Labimotion::ElementKlass.find_by(name: params[:el_type])
-        allowed_fields = element_klass.properties_release.dig(Labimotion::Prop::LAYERS, layer, Labimotion::Prop::FIELDS)&.pluck('field') || []
+        allowed_fields = element_klass&.properties_release&.dig(Labimotion::Prop::LAYERS, layer, Labimotion::Prop::FIELDS)&.pluck('field') || []
 
         if field.in?(allowed_fields)
           query = ActiveRecord::Base.sanitize_sql(
@@ -247,27 +247,21 @@ module Labimotion
     end
 
     def list_serialized_elements(params, current_user)
-      collection_id =
-      if params[:collection_id]
-        Collection
-          .belongs_to_or_shared_by(current_user.id, current_user.group_ids)
-          .find_by(id: params[:collection_id])&.id
-      elsif params[:sync_collection_id]
-        current_user
-          .all_sync_in_collections_users
-          .find_by(id: params[:sync_collection_id])&.collection&.id
-      end
+      scope = Labimotion::Element.none
 
-      scope =
-      if collection_id
-        Labimotion::Element
-          .joins(:element_klass, :collections_elements)
-          .where(
-            element_klasses: { name: params[:el_type] },
-            collections_elements: { collection_id: collection_id },
-          ).includes(:tag, collections: :sync_collections_users)
+      if params[:collection_id]
+        begin
+          collection = Collection.accessible_for(current_user).find(params[:collection_id])
+          scope = collection.elements
+                            .joins(:element_klass)
+                            .where(element_klasses: { name: params[:el_type] })
+                            .includes(:tag)
+        rescue ActiveRecord::RecordNotFound
+          Labimotion::Element.none
+        end
       else
-        Labimotion::Element.none
+        # All collection of current_user
+        scope = Labimotion::Element.for_user(current_user.id)
       end
 
       ## TO DO: refactor labimotion
@@ -278,7 +272,7 @@ module Labimotion
         layer, field = params[:sort_column].split('.')
 
         element_klass = Labimotion::ElementKlass.find_by(name: params[:el_type])
-        allowed_fields = element_klass.properties_release.dig(Labimotion::Prop::LAYERS, layer, Labimotion::Prop::FIELDS)&.pluck('field') || []
+        allowed_fields = element_klass&.properties_release&.dig(Labimotion::Prop::LAYERS, layer, Labimotion::Prop::FIELDS)&.pluck('field') || []
 
         if field.in?(allowed_fields)
           query = ActiveRecord::Base.sanitize_sql(

data/lib/labimotion/models/concerns/element_fetchable.rb

@@ -26,9 +26,9 @@ module Labimotion
           joins(collections: :user).where(collections: { user_id: user_id })
         )
 
-        # Shared (synced) records
+        # Shared records
         shared = apply_filters.call(
-          joins(collections: :sync_collections_users).where(sync_collections_users: { user_id: user_id })
+          left_joins(:collection_shares).where(collection_shares: { shared_with_id: user_id })
         )
 
         # Combine (remove duplicates), order, and limit

data/lib/labimotion/models/element.rb

@@ -141,9 +141,9 @@ module Labimotion
         joins(collections: :user).where(collections: { user_id: user_id })
       )
 
-      # Shared (synced) elements
+      # Shared elements
       shared = apply_filters.call(
-        joins(collections: :sync_collections_users).where(sync_collections_users: { user_id: user_id })
+        left_joins(:collection_shares).where(collection_shares: { shared_with_id: user_id })
       )
 
       # Combine (remove duplicates), order, and limit

data/lib/labimotion/usecases/build_template_doi_xml.rb

@@ -11,11 +11,7 @@ module Labimotion
   class BuildTemplateDoiXml
     include ::DataCitePublisher
 
-    # The template ships with the gem. A host app may still override it by
-    # placing its own copy at HOST_TEMPLATE_PATH, which is how it used to be
-    # sourced — hence the lookup order below.
-    GEM_TEMPLATE_PATH = File.expand_path('../libs/data/datacite/labimotion_template.html.erb', __dir__)
-    HOST_TEMPLATE_PATH = 'app/publish/datacite_metadata_labimotion_template.html.erb'
+    TEMPLATE_PATH = Rails.root.join('app/publish/datacite_metadata_labimotion_template.html.erb')
 
     RESOURCE_LABEL = {
       'element' => 'LabIMotion Element Template',
@@ -23,28 +19,21 @@ module Labimotion
       'dataset' => 'LabIMotion Dataset Template'
     }.freeze
 
-    def initialize(record, doi = nil)
+    def initialize(record, doi = nil, current_user = nil)
       @record = record
       @doi = doi || ::Doi.labimotion_latest_doi(record)
+      @current_user = current_user
     end
 
     # Returns the XML string, or nil when no DOI has been reserved yet.
     def call
       return nil if @doi.nil?
 
-      ERB.new(File.read(template_path), trim_mode: '-').result(binding)
+      ERB.new(File.read(TEMPLATE_PATH), trim_mode: '-').result(binding)
     end
 
     private
 
-    # Resolved per call rather than at load time, so the class no longer needs
-    # Rails to be booted just to be autoloaded.
-    def template_path
-      # `Rails.root` is still nil if Rails is loaded but the app has not booted.
-      host = defined?(Rails) && Rails.respond_to?(:root) ? Rails.root&.join(HOST_TEMPLATE_PATH) : nil
-      host && File.exist?(host) ? host : GEM_TEMPLATE_PATH
-    end
-
     def full_doi
       @doi.full_doi
     end
@@ -76,70 +65,35 @@ module Labimotion
     end
 
     def creators
-      Array(publication['authors']).filter_map { |author| person(author) }
-    end
+      Array(publication['authors']).filter_map do |author|
+        next unless author.is_a?(Hash)
 
-    # The people credited as DataCite contributors, each in their own role.
-    # Held apart from the creators — a contributor need not be one of the
-    # authors — and empty (no contributors block) until one is named; they are
-    # never inferred from whoever happens to be publishing. DOIs released
-    # before contributors became a list carry a single `contributor`.
-    def contributors
-      list = publication['contributors']
-      list = [publication['contributor']].compact unless list.is_a?(Array)
-      list.filter_map do |entry|
-        person(entry)&.merge('contributorType' => h(contributor_type(entry)))
-      end
-    end
+        given = author['givenName'].to_s.strip
+        family = author['familyName'].to_s.strip
+        next if given.empty? && family.empty?
 
-    def contributor_type(entry)
-      type = entry['contributorType'].to_s.strip
-      types = TemplateDoiHelpers::CONTRIBUTOR_TYPES
-      types.include?(type) ? type : TemplateDoiHelpers::DEFAULT_CONTRIBUTOR_TYPE
+        { 'givenName' => h(given), 'familyName' => h(family),
+          'orcid' => h(author['orcid'].to_s.strip), 'affiliation' => h(author['affiliation'].to_s.strip) }
+      end
     end
 
-    # A creator or contributor, escaped for the template. Nameless entries are
-    # dropped: DataCite has nowhere to put an ORCID or affiliation on its own.
-    # `ror` is the resolver URI DataCite expects in affiliationIdentifier,
-    # rebuilt from the bare id that is stored.
-    def person(entry)
-      return nil unless entry.is_a?(Hash)
+    # The acting user, rendered as a DataCite "Researcher" contributor. Nil
+    # (no contributors block) when there is no user or they have no name.
+    def contributor
+      user = @current_user
+      return nil unless user
 
-      given = entry['givenName'].to_s.strip
-      family = entry['familyName'].to_s.strip
+      given = user.try(:first_name).to_s.strip
+      family = user.try(:last_name).to_s.strip
       return nil if given.empty? && family.empty?
 
-      ror = entry['ror_id'].to_s.strip
-      { 'givenName' => h(given), 'familyName' => h(family), 'orcid' => h(entry['orcid'].to_s.strip),
-        'affiliation' => h(entry['affiliation'].to_s.strip),
-        'ror' => ror.empty? ? '' : h("https://ror.org/#{ror}") }
+      orcid = user.respond_to?(:orcid) ? user.orcid.to_s.strip : ''
+      { 'givenName' => h(given), 'familyName' => h(family), 'orcid' => h(orcid) }
     end
 
-    # Works this template cites, published as DataCite relatedIdentifiers of
-    # relationType "References". Only the DOI travels — a relatedIdentifier
-    # carries no title — so entries without one are skipped.
-    def references
-      Array(publication['references']).filter_map do |reference|
-        next unless reference.is_a?(Hash)
-
-        doi = reference['doi'].to_s.strip
-        next if doi.empty?
-
-        { 'doi' => h(doi) }
-      end
-    end
-
-    # What this DOI renders: the snapshot taken when it was released, so every
-    # released version keeps showing the metadata it was published with rather
-    # than the template's latest. A DOI that is still reserved has no snapshot
-    # and renders the template's current publication, which is what is still
-    # being edited for it.
     def publication
-      @publication ||= ::Doi.labimotion_doi_publication(@doi).presence || record_publication
-    end
-
-    def record_publication
-      (@record.properties_template.is_a?(Hash) ? @record.properties_template['publication'] : nil) || {}
+      @publication ||=
+        (@record.properties_template.is_a?(Hash) ? @record.properties_template['publication'] : nil) || {}
     end
 
     def h(value)

data/lib/labimotion/usecases/release_template_doi.rb

@@ -24,8 +24,7 @@ module Labimotion
       return failure('doi not reserved') if @doi.nil?
       return self if @doi.minted
 
-      missing = missing_metadata
-      return failure("publication metadata is incomplete: #{missing.join(', ')}") if missing.any?
+      return failure('publication metadata is incomplete') unless metadata_ready?
 
       publish_at_datacite
       self
@@ -38,33 +37,22 @@ module Labimotion
     private
 
     def publish_at_datacite
-      datacite_failure = send_to_datacite? ? mint_at_datacite : nil
-      return failure(datacite_failure) if datacite_failure
+      if send_to_datacite?
+        mds = ::Repo::Datacite::Mds.new
+        # DataCite requires the metadata to exist before the DOI can be minted.
+        metadata = mds.upload_metadata(BuildTemplateDoiXml.new(record, doi, current_user).call)
+        return failure(datacite_error('metadata upload', metadata)) unless metadata.is_a?(Net::HTTPSuccess)
+
+        response = mds.mint(doi.full_doi, TemplateDoiHelpers.template_url(record))
+        return failure(datacite_error('mint', response)) unless response.is_a?(Net::HTTPSuccess)
+      end
 
       ActiveRecord::Base.transaction do
-        # The publication is snapshotted onto the DOI as it is minted, so this
-        # version keeps rendering what it was published with once the template's
-        # metadata moves on to the next version.
-        doi.update!(minted: true, minted_at: Time.current,
-                    metadata: ::Doi.labimotion_metadata_with_publication(doi, publication))
+        doi.update!(minted: true, minted_at: Time.current)
         stamp_release_on_record
       end
     end
 
-    # Uploads the metadata and mints the DOI at DataCite. Returns an error
-    # message, or nil when both calls succeeded.
-    def mint_at_datacite
-      mds = ::Repo::Datacite::Mds.new
-      # DataCite requires the metadata to exist before the DOI can be minted.
-      metadata = mds.upload_metadata(BuildTemplateDoiXml.new(record, doi).call)
-      return datacite_error('metadata upload', metadata) unless metadata.is_a?(Net::HTTPSuccess)
-
-      response = mds.mint(doi.full_doi, TemplateDoiHelpers.template_url(record))
-      return datacite_error('mint', response) unless response.is_a?(Net::HTTPSuccess)
-
-      nil
-    end
-
     def datacite_error(step, response)
       status = response.respond_to?(:code) ? response.code : 'unknown'
       "datacite #{step} failed (status #{status})"
@@ -85,26 +73,13 @@ module Labimotion
       record.update!(attrs) if attrs.any?
     end
 
-    # Everything the publication form owns that DataCite needs, named so the
-    # modal can say what is still missing. Contributors and references are
-    # optional: not every template credits a role beyond its authors, and not
-    # every template cites a work.
-    def missing_metadata
-      missing = %w[title description].reject { |key| publication[key].to_s.strip.present? }
-      missing << 'authors' unless Array(publication['authors']).any? { |author| named?(author) }
-      missing
-    end
-
-    def named?(person)
-      person.is_a?(Hash) && person['familyName'].to_s.strip.present?
-    end
+    def metadata_ready?
+      publication = record.properties_template.is_a?(Hash) ? record.properties_template['publication'] : nil
+      return false unless publication.is_a?(Hash)
 
-    # The template's current publication metadata — what this release publishes.
-    def publication
-      @publication ||= begin
-        pub = record.properties_template.is_a?(Hash) ? record.properties_template['publication'] : nil
-        pub.is_a?(Hash) ? pub : {}
-      end
+      publication['title'].to_s.strip.present? &&
+        publication['description'].to_s.strip.present? &&
+        Array(publication['authors']).any? { |a| a.is_a?(Hash) && a['familyName'].to_s.strip.present? }
     end
 
     def failure(message)

data/lib/labimotion/usecases/template_doi_helpers.rb

@@ -20,24 +20,6 @@ module Labimotion
       ::Labimotion::DatasetKlass => 'datasets'
     }.freeze
 
-    # Where the hub lives, most specific first. PUBLIC_URL is the instance's own
-    # public address (the host app's config/application.rb insists on it), so the
-    # link follows whichever instance is serving it rather than a hardcoded
-    # chemotion-repository.net. The DataCite-facing domains stay as fallbacks for
-    # deployments that only set those.
-    HOST_ENV_KEYS = %w[PUBLIC_URL REPO_HOST DOI_DOMAIN_TEST DOI_DOMAIN].freeze
-
-    # The DataCite kernel-4 contributorType vocabulary. A template DOI may name
-    # any number of contributors — including none — each credited in one of
-    # these roles. The list is closed: DataCite rejects anything else.
-    CONTRIBUTOR_TYPES = %w[
-      ContactPerson DataCollector DataCurator DataManager Distributor Editor
-      HostingInstitution Producer ProjectLeader ProjectManager ProjectMember
-      RegistrationAgency RegistrationAuthority RelatedPerson Researcher
-      ResearchGroup RightsHolder Sponsor Supervisor WorkPackageLeader Other
-    ].freeze
-    DEFAULT_CONTRIBUTOR_TYPE = 'Researcher'
-
     module_function
 
     # True once the template's latest DOI has been released (minted) and the
@@ -67,17 +49,13 @@ module Labimotion
     # Used as the DOI's DataCite landing page and surfaced in the UI.
     def template_url(record)
       type = klass_type_for(record)
+      host = ENV['REPO_HOST'].presence || ENV['DOI_DOMAIN_TEST'].presence ||
+             ENV['DOI_DOMAIN'].presence || 'https://www.chemotion-repository.net'
       record_id = record.try(:identifier).presence || record.try(:uuid).presence || record.id
       query = "type=finder&kind=#{type}&id=#{record_id}"
       version = record.try(:version)
       query += "&version=#{version}" if version.present?
-      "#{public_host}/home/genericHub?#{query}"
-    end
-
-    # The instance serving the hub, without its trailing slash.
-    def public_host
-      host = HOST_ENV_KEYS.lazy.filter_map { |key| ENV[key].presence }.first
-      (host || 'http://localhost:3000').chomp('/')
+      "#{host.chomp('/')}/home/genericHub?#{query}"
     end
 
     # A user may manage a template's DOI iff they hold the LabIMotion

data/lib/labimotion/usecases/update_template_publication_metadata.rb

@@ -7,12 +7,7 @@ module Labimotion
   class UpdateTemplatePublicationMetadata
     include TemplateDoiHelpers
 
-    ALLOWED_KEYS = %w[title description authors contributors references license].freeze
-    REFERENCE_KEYS = %w[doi title url].freeze
-    # Authors and contributors are the same shape: a DataCite personal name plus
-    # the identifiers that make it resolvable — ORCID for the person, ROR for
-    # their organisation. Contributors carry a contributorType on top.
-    PERSON_KEYS = %w[givenName familyName orcid affiliation affiliation_id ror_id].freeze
+    ALLOWED_KEYS = %w[title description authors license].freeze
 
     attr_reader :record, :current_user, :publication, :error
 
@@ -44,82 +39,18 @@ module Labimotion
     def normalized_publication
       slice = publication.stringify_keys.slice(*ALLOWED_KEYS)
       slice['authors'] = Array(slice['authors']).filter_map { |a| normalize_author(a) }
-      # Contributors are people in their own right — none of them need be one of
-      # the authors — so they are stored as given rather than matched back
-      # against the author list. There may be any number, including none.
-      slice['contributors'] = submitted_contributors.filter_map { |c| normalize_contributor(c) }
-      slice['references'] = Array(slice['references']).filter_map { |r| normalize_reference(r) }
       slice
     end
 
-    # A single `contributor` is what the first version of the form sent; a
-    # template saved by it is read back into the list rather than dropped.
-    def submitted_contributors
-      given = publication.stringify_keys
-      given['contributors'].is_a?(Array) ? given['contributors'] : [given['contributor']].compact
-    end
-
-    # A person plus the DataCite role they are credited in. An unknown or
-    # missing role falls back to "Researcher" rather than failing the save —
-    # the vocabulary is closed, so anything else would be rejected at minting.
-    def normalize_contributor(contributor)
-      h = normalize_author(contributor)
-      return nil unless h
-
-      type = contributor.stringify_keys['contributorType'].to_s.strip
-      known = TemplateDoiHelpers::CONTRIBUTOR_TYPES.include?(type)
-      h.merge('contributorType' => known ? type : TemplateDoiHelpers::DEFAULT_CONTRIBUTOR_TYPE)
-    end
-
-    # A cited work, identified by its DOI. Anything without one is dropped: the
-    # DOI is what goes to DataCite as a relatedIdentifier, and a reference
-    # without it would be published as an empty relation.
-    def normalize_reference(reference)
-      return nil unless reference.is_a?(Hash)
-
-      h = reference.stringify_keys.slice(*REFERENCE_KEYS)
-      h['doi'] = sanitize_doi(h['doi'])
-      return nil if h['doi'].nil?
-
-      h.transform_values { |v| v.to_s.strip }
-    end
-
-    # Accepts a bare DOI, a doi: prefix or a resolver URL, and keeps the bare
-    # "10.x/y" form. Nil for anything that is not a DOI.
-    def sanitize_doi(value)
-      match = value.to_s.strip.match(%r{(10\.\d{4,9}/\S+)\z})
-      match && match[1]
-    end
-
     def normalize_author(author)
       return nil unless author.is_a?(Hash)
 
-      h = author.stringify_keys.slice(*PERSON_KEYS)
+      h = author.stringify_keys.slice('givenName', 'familyName', 'orcid', 'affiliation', 'affiliation_id')
       return nil if h.values_at('givenName', 'familyName').all? { |v| v.to_s.strip.empty? }
 
-      ror = normalize_ror(h['ror_id']) || ror_for(h['affiliation_id'])
-      ror ? h['ror_id'] = ror : h.delete('ror_id')
       h
     end
 
-    # ROR IDs travel either bare ("05f950310") or as a resolver URL; DataCite
-    # wants the URI, so the bare form is what gets stored and the URI is built
-    # when the XML is rendered.
-    def normalize_ror(value)
-      value.to_s.strip.sub(%r{\Ahttps?://ror\.org/}i, '').presence
-    end
-
-    # The authoritative ROR for a picked affiliation. Whoever the editor picked
-    # came from an Affiliation record, so its id is the better source than
-    # anything retyped — and the current-user payload carries no ROR at all.
-    def ror_for(affiliation_id)
-      return nil if affiliation_id.blank? || !defined?(::Affiliation)
-
-      normalize_ror(::Affiliation.where(id: affiliation_id).pick(:ror_id))
-    rescue StandardError
-      nil
-    end
-
     def failure(message)
       @error = message
       self

data/lib/labimotion/utils/search.rb

@@ -12,7 +12,7 @@ module Labimotion
     end
 
     def self.elements_search(params, current_user, c_id, dl)
-      collection = Collection.belongs_to_or_shared_by(current_user.id, current_user.group_ids).find(c_id)
+      collection = Collection.accessible_for(current_user).find(c_id)
       element_scope = Labimotion::Element.joins(:collections_elements).where('collections_elements.collection_id = ?', collection.id).joins(:element_klass).where('element_klasses.id = elements.element_klass_id AND element_klasses.name = ?', params[:selection][:genericElName])
       element_scope = element_scope.where('elements.name like (?)', "%#{params[:selection][:searchName]}%") if params[:selection][:searchName].present?
       element_scope = element_scope.where('elements.short_label like (?)', "%#{params[:selection][:searchShowLabel]}%") if params[:selection][:searchShowLabel].present?
@@ -97,7 +97,7 @@ module Labimotion
     def self.samples_search(c_id = @c_id)
       sqls = []
       sps = params[:selection][:searchProperties]
-      collection = Collection.belongs_to_or_shared_by(current_user.id, current_user.group_ids).find(c_id)
+      collection = Collection.accessible_for(current_user).find(c_id)
       element_scope = Sample.joins(:collections_samples).where('collections_samples.collection_id = ?', collection.id)
       return element_scope if sps.empty?
 

data/lib/labimotion/utils/units.rb

@@ -51,6 +51,20 @@ module Labimotion
         { "key": "pmol", "label": "pmol", "nm": 1.0e12 }
       ]
     },
+    {
+      "type": "numeric",
+      "field": "areal_density",
+      "label": "Areal density",
+      "default": "",
+      "position": 38,
+      "placeholder": "areal density",
+      "units": [
+        { "key": "kg_m2", "label": "kg m<sup>-2</sup>", "nm": 1 },
+        { "key": "t_m2", "label": "t m<sup>-2</sup>", "nm": 0.001 },
+        { "key": "kg_cm2", "label": "kg cm<sup>-2</sup>", "nm": 1e-4 },
+        { "key": "g_m2", "label": "g m<sup>-2</sup>", "nm": 1000 }
+      ]
+    },
     {
       "type": "numeric",
       "field": "molarity",
@@ -93,16 +107,34 @@ module Labimotion
       "field": "conductivity",
       "label": "Conductivity",
       "default": "",
-      "position": 66,
+      "position": 62,
       "placeholder": "conductivity",
-      "units": [{ "key": "s_m", "label": "S/m", "nm": 1 }]
+      "units": [
+        { "key": "s_m", "label": "S/m", "nm": 1 },
+        { "key": "ms_cm", "label": "mS/cm", "nm": 10 }
+      ]
+    },
+    {
+      "type": "numeric",
+      "field": "currency",
+      "label": "Currency",
+      "default": "",
+      "position": 64,
+      "placeholder": "Currency",
+      "units": [
+        { "key": "eur", "label": "EUR", "nm": 1, "unit_type": "eur" },
+        { "key": "chf", "label": "CHF", "nm": 1, "unit_type": "chf" },
+        { "key": "gbp", "label": "GBP", "nm": 1, "unit_type": "gbp" },
+        { "key": "usd", "label": "USD", "nm": 1, "unit_type": "usd" },
+        { "key": "jpy", "label": "JPY", "nm": 1, "unit_type": "jpy" }
+      ]
     },
     {
       "type": "numeric",
       "field": "current",
       "label": "Current",
       "default": "",
-      "position": 60,
+      "position": 67,
       "placeholder": "Current",
       "units": [
         { "key": "A", "label": "A", "nm": 1 },
@@ -251,6 +283,17 @@ module Labimotion
         { "key": "k_j", "label": "kJ", "nm": 1 }
       ]
     },
+    {
+      "type": "numeric",
+      "field": "free_energy",
+      "label": "Free Energy/enthalpy",
+      "default": "",
+      "position": 89,
+      "placeholder": "Free Energy/enthalpy",
+      "units": [
+        { "key": "kj_mol", "label": "kJ/mol", "nm": 1 }
+      ]
+    },
     {
       "type": "numeric",
       "field": "enzyme_activity",
@@ -260,9 +303,9 @@ module Labimotion
       "placeholder": "Enzyme activity",
       "units": [
         { "key": "u_l", "label": "U/L", "nm": 1 },
-        { "key": "u_ml", "label": "U/mL", "nm": 10e-3 },
-        { "key": "u_g", "label": "U/g", "nm": 10e-3 },
-        { "key": "u_mg", "label": "U/mg", "nm": 10e-6 }
+        { "key": "u_ml", "label": "U/mL", "nm": 1e-3 },
+        { "key": "u_g", "label": "U/g", "nm": 1e-3 },
+        { "key": "u_mg", "label": "U/mg", "nm": 1e-6 }
       ]
     },
     {
@@ -284,9 +327,10 @@ module Labimotion
       "position": 100,
       "placeholder": "Flow rate",
       "units": [
-        { "key": "ul_min", "label": "µl/min", "nm": 1000000 },
-        { "key": "ml_min", "label": "ml/min", "nm": 1000 },
-        { "key": "l_m", "label": "l/m", "nm": 1 }
+        { "key": "l_m", "label": "L/min", "nm": 1 },
+        { "key": "ml_min", "label": "mL/min", "nm": 1000 },
+        { "key": "ul_min", "label": "µL/min", "nm": 1000000 },
+        { "key": "ml_h", "label": "mL/h", "nm": 60000 }
       ]
     },
     {
@@ -297,19 +341,26 @@ module Labimotion
       "position": 103,
       "placeholder": "frequency",
       "units": [
-        { "key": "mhz", "label": "MHz", "nm": 1000000 },
-        { "key": "hz", "label": "Hz", "nm": 1000 },
-        { "key": "khz", "label": "kHz", "nm": 1 }
+        { "key": "hz", "label": "Hz", "nm": 1 },
+        { "key": "khz", "label": "kHz", "nm": 1e-3 },
+        { "key": "mhz", "label": "MHz", "nm": 1e-6 }
       ]
     },
     {
       "type": "numeric",
       "field": "heating_rate",
-      "label": "Heating rate",
+      "label": "Heating rate (Temperature ramp)",
       "default": "",
       "position": 106,
       "placeholder": "heating rate",
-      "units": [{ "key": "k_min", "label": "K/min", "nm": 1 }]
+      "units": [
+        { "key": "k_min", "label": "K/min", "nm": 1 },
+        { "key": "k_s", "label": "K/s", "nm": 0.016666666666667 },
+        { "key": "k_h", "label": "K/h", "nm": 60 },
+        { "key": "degc_min", "label": "°C min<sup>-1</sup>", "nm": 1 },
+        { "key": "degc_s", "label": "°C s<sup>-1</sup>", "nm": 0.016666666666667 },
+        { "key": "degc_h", "label": "°C h<sup>-1</sup>", "nm": 60 }
+      ]
     },
     {
       "type": "numeric",
@@ -346,6 +397,29 @@ module Labimotion
         { "key": "ug", "label": "µg", "nm": 1000000 }
       ]
     },
+    {
+      "type": "numeric",
+      "field": "mass_fraction",
+      "label": "Mass fraction",
+      "default": "",
+      "position": 123,
+      "placeholder": "mass fraction",
+      "units": [
+        { "key": "wt_p", "label": "wt.%", "nm": 1 }
+      ]
+    },
+    {
+      "type": "numeric",
+      "field": "mass_loading",
+      "label": "Mass loading",
+      "default": "",
+      "position": 125,
+      "placeholder": "mass loading",
+      "units": [
+        { "key": "g_cm2", "label": "g cm<sup>-2</sup>", "nm": 1 },
+        { "key": "mg_cm2", "label": "mg cm<sup>-2</sup>", "nm": 1000 }
+      ]
+    },
     {
       "type": "numeric",
       "field": "mass_molecule",
@@ -358,6 +432,28 @@ module Labimotion
         { "key": "kilo_dalton", "label": "kD", "nm": 1 }
       ]
     },
+    {
+      "type": "numeric",
+      "field": "molar_conductivity",
+      "label": "Molar conductivity",
+      "default": "",
+      "position": 127,
+      "placeholder": "molar conductivity",
+      "units": [
+        { "key": "s_cm2_mol", "label": "S cm<sup>2</sup> mol<sup>-1</sup>", "nm": 1 }
+      ]
+    },
+    {
+      "type": "numeric",
+      "field": "molar_entropy",
+      "label": "Molar Entropy",
+      "default": "",
+      "position": 128,
+      "placeholder": "Molar Entropy",
+      "units": [
+        { "key": "j_mol_k", "label": "J/(mol*K)", "nm": 1 }
+      ]
+    },
     {
       "type": "numeric",
       "field": "molecular_weight",
@@ -402,6 +498,30 @@ module Labimotion
         { "key": "mbar", "label": "mbar", "nm": 1013.25 }
       ]
     },
+    {
+      "type": "numeric",
+      "field": "process_rate",
+      "label": "Process rate",
+      "default": "",
+      "position": 143,
+      "placeholder": "Process rate",
+      "units": [
+        { "key": "1_s", "label": "1/s", "nm": 1 },
+        { "key": "1_min", "label": "1/min", "nm": 60 },
+        { "key": "1_h", "label": "1/h", "nm": 3600 }
+      ]
+    },
+    {
+      "type": "numeric",
+      "field": "rate_constant",
+      "label": "Rate constant",
+      "default": "",
+      "position": 146,
+      "placeholder": "Rate constant",
+      "units": [
+        { "key": "1_m_s", "label": "1/(M*s)", "nm": 1 }
+      ]
+    },
     {
       "type": "numeric",
       "field": "reaction_rate",
@@ -410,8 +530,8 @@ module Labimotion
       "position": 150,
       "placeholder": "Reaction rate",
       "units": [
-        { "key": "mol_lmin", "label": "mol/Lmin", "nm": 1 },
-        { "key": "mol_lsec", "label": "mol/Ls", "nm": 60 }
+        { "key": "mol_lmin", "label": "mol L<sup>-1</sup> min<sup>-1</sup>", "nm": 1 },
+        { "key": "mol_lsec", "label": "mol L<sup>-1</sup> s<sup>-1</sup>", "nm": 0.016666666666667 }
       ]
     },
     {
@@ -448,8 +568,9 @@ module Labimotion
       "units": [
         { "key": "ma_g", "label": "mA/g", "nm": 1000, "unit_type": "mass" },
         { "key": "a_g", "label": "A/g", "nm": 1, "unit_type": "mass" },
+        { "key": "ma_cm2", "label": "mA/cm<sup>2</sup>", "nm": 1000, "unit_type": "area" },
         { "key": "a_cm2", "label": "A/cm<sup>2</sup>", "nm": 1, "unit_type": "area" },
-        { "key": "ma_cm2", "label": "mA/cm<sup>2</sup>", "nm": 1000, "unit_type": "area" }
+        { "key": "a_mm2", "label": "A/mm<sup>2</sup>", "nm": 0.01, "unit_type": "area" }
       ]
     },
     {
@@ -495,7 +616,7 @@ module Labimotion
         { "key": "cm_s", "label": "cm/s", "nm": 1 },
         { "key": "mm_s", "label": "mm/s", "nm": 10 },
         { "key": "um_m", "label": "µm/min", "nm": 600000 },
-        { "key": "nm_m", "label": "nm/min", "nm": 60000000 },
+        { "key": "nm_m", "label": "nm/min", "nm": 600000000 },
         { "key": "cm_h", "label": "cm/h", "nm": 3600 },
         { "key": "mm_h", "label": "mm/h", "nm": 36000 }
       ]
@@ -540,6 +661,31 @@ module Labimotion
         { "key": "K", "label": "K" }
       ]
     },
+    {
+      "type": "numeric",
+      "field": "tensile_force",
+      "label": "Tensile force",
+      "default": "",
+      "position": 185,
+      "placeholder": "tensile force",
+      "units": [
+        { "key": "n", "label": "N", "nm": 1 },
+        { "key": "kn", "label": "kN", "nm": 0.001 },
+        { "key": "mn", "label": "mN", "nm": 1000 }
+      ]
+    },
+    {
+      "type": "numeric",
+      "field": "tensile_stress",
+      "label": "Tensile stress",
+      "default": "",
+      "position": 186,
+      "placeholder": "tensile stress",
+      "units": [
+        { "key": "n_cm2", "label": "N cm<sup>-2</sup>", "nm": 1 },
+        { "key": "n_mm2", "label": "N mm<sup>-2</sup>", "nm": 0.01 }
+      ]
+    },
     {
       "type": "numeric",
       "field": "turnover_number",
@@ -575,7 +721,7 @@ module Labimotion
       "field": "voltage",
       "label": "Voltage",
       "default": "",
-      "position": 200,
+      "position": 206,
       "placeholder": "voltage",
       "units": [
         { "key": "mv", "label": "mV", "nm": 1000 },
@@ -597,6 +743,17 @@ module Labimotion
         { "key": "nl", "label": "nl", "nm": 1000000000 }
       ]
     },
+    {
+      "type": "numeric",
+      "field": "volume_fraction",
+      "label": "Volume fraction",
+      "default": "",
+      "position": 218,
+      "placeholder": "volume fraction",
+      "units": [
+        { "key": "vol_p", "label": "vol.%", "nm": 1 }
+      ]
+    },
     {
       "type": "numeric",
       "field": "volumes_metric",
@@ -610,6 +767,6 @@ module Labimotion
         { "key": "m3", "label": "m³", "nm": 0.000001 }
       ]
     }
-  ]
+    ]
   end
 end

data/lib/labimotion/version.rb

@@ -2,5 +2,5 @@
 
 ## Labimotion Version
 module Labimotion
-  VERSION = '2.2.0.rc22'
+  VERSION = '2.3.0.rc1'
 end

data/lib/labimotion.rb

@@ -148,5 +148,4 @@ module Labimotion
   autoload :Datasetable, 'labimotion/models/concerns/datasetable'
   autoload :AttachmentConverter, 'labimotion/models/concerns/attachment_converter'
   autoload :LinkedProperties, 'labimotion/models/concerns/linked_properties'
-  autoload :TemplateDoi, 'labimotion/models/concerns/template_doi'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.2.0.rc22
+  version: 2.3.0.rc1
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-07-29 00:00:00.000000000 Z
+date: 2026-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: caxlsx
@@ -111,7 +111,6 @@ files:
 - lib/labimotion/helpers/vocabulary_helpers.rb
 - lib/labimotion/libs/attachment_handler.rb
 - lib/labimotion/libs/converter.rb
-- lib/labimotion/libs/data/datacite/labimotion_template.html.erb
 - lib/labimotion/libs/data/mapper/Chemwiki.json
 - lib/labimotion/libs/data/mapper/Source.json
 - lib/labimotion/libs/data/vocab/Standard.json
@@ -137,7 +136,6 @@ files:
 - lib/labimotion/models/concerns/linked_properties.rb
 - lib/labimotion/models/concerns/metadata_validation.rb
 - lib/labimotion/models/concerns/segmentable.rb
-- lib/labimotion/models/concerns/template_doi.rb
 - lib/labimotion/models/concerns/workflow.rb
 - lib/labimotion/models/dataset.rb
 - lib/labimotion/models/dataset_klass.rb

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

@@ -1,67 +0,0 @@
-<?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/models/concerns/template_doi.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-# TemplateDoi concern
-#
-# LabIMotion template DOI logic for the host's Doi model. The host owns the DOI
-# record and the generic DataCite plumbing (build_suffix/align_suffix, the MDS
-# client, the DataCitePublisher concern); this adds only the LabIMotion-specific
-# class methods that the gem's template DOI usecases and APIs call on ::Doi.
-#
-# The host wires it up with a single line:
-#   class Doi < ApplicationRecord
-#     include Labimotion::TemplateDoi
-#   end
-#
-# Assumes the host `dois` table has a jsonb `metadata` column (the DOI version
-# is stamped there) and that the deterministic suffix survives Doi#align_suffix
-# unchanged (reserve sets inchikey == suffix and version_count: 0 for that).
-module Labimotion
-  module TemplateDoi
-    extend ActiveSupport::Concern
-
-    # Literal namespace shared by every LabIMotion template DOI suffix.
-    LABIMOTION_DOI_NAMESPACE = 'labimotion'
-
-    # ActiveSupport::Concern extends this into the including class, so every
-    # method below becomes a class method on the host's Doi.
-    module ClassMethods
-      # Deterministic DOI suffix for a LabIMotion template klass. The same suffix
-      # is used at reserve and at release time, so both share one DOI:
-      #   element -> labimotion/element/<name>/<identifier>/<doi_version>
-      #   segment -> labimotion/segment/<element>/<identifier>/<doi_version>
-      #   dataset -> labimotion/dataset/<ols_term_id>/<identifier>/<doi_version>
-      # `<identifier>` is the first UUID group (8 hex chars) of the template's
-      # identifier/uuid, falling back to the record id. `<doi_version>` is the DOI
-      # version (see .labimotion_version_segment). Callers may pass an explicit
-      # template version; otherwise the record's current version is used.
-      def build_labimotion_suffix(record, version = nil)
-        parts = labimotion_suffix_parts(record)
-        raise ArgumentError, "unsupported template: #{record.class}" if parts.nil?
-
-        segment = labimotion_version_segment(record, version)
-        return nil if segment.blank?
-
-        segments = parts.map { |part| sanitize_doi_part(part) }.reject(&:empty?)
-        "#{segments.join('/')}/#{segment}"
-      end
-
-      # The DOI version segment for a template version. A DOI is published per major
-      # release: the .0 release opens that version (X.0 -> "X") and later minor
-      # revisions roll into the NEXT DOI (X.y, y>=1 -> "X+1"). Sub-1.0 and
-      # unversioned/blank templates map to the first DOI (v1).
-      #   0.x -> "1"   1.0 -> "1"   1.1..2.0 -> "2"   2.1..3.0 -> "3"
-      def labimotion_version_segment(record, version = nil)
-        raw = (version.presence || record.try(:version)).to_s.strip
-        parts = raw.split('.')
-        major = parts[0].to_i
-        minor = parts[1].to_i
-        return '1' if major.zero?
-        return major.to_s if minor.zero?
-
-        (major + 1).to_s
-      end
-
-      # The DOIs reserved for a LabIMotion template, in reservation order.
-      def labimotion_dois(record)
-        where(doiable_id: record.id, doiable_type: record.class.name).order(:id).to_a
-      end
-
-      # The current (most recently reserved) DOI for a template, or nil.
-      def labimotion_latest_doi(record)
-        labimotion_dois(record).last
-      end
-
-      # The DOI version (next-major integer) recorded on a reserved template DOI.
-      def labimotion_doi_version(doi)
-        doi.metadata.to_h.dig('labimotion', 'doi_version')
-      end
-
-      # Metadata stamped on a reserved template DOI so the version it represents
-      # survives on the record (used to gate reserving the next version).
-      def labimotion_doi_metadata(record, version = nil)
-        { 'labimotion' => { 'doi_version' => labimotion_version_segment(record, version) } }
-      end
-
-      # The publication metadata a released template DOI was published with.
-      # Nil while the DOI is still reserved, and for DOIs released before
-      # snapshots were kept — callers fall back to the template's current
-      # publication in both cases.
-      def labimotion_doi_publication(doi)
-        doi.metadata.to_h.dig('labimotion', 'publication')
-      end
-
-      # The DOI's metadata with the publication snapshotted into it, keeping
-      # the DOI version already stamped there. Taken at release: the template's
-      # publication keeps being edited for the next version, and this version
-      # must stop tracking those edits.
-      def labimotion_metadata_with_publication(doi, publication)
-        metadata = doi.metadata.to_h
-        # Deep-duped: the snapshot must not alias the template's publication,
-        # which goes on being edited for the next version.
-        labimotion = (metadata['labimotion'] || {}).merge('publication' => publication.deep_dup)
-        metadata.merge('labimotion' => labimotion)
-      end
-
-      def labimotion_suffix_parts(record)
-        # identifier/uuid may both be blank for a draft, which would collapse the
-        # scope (colliding across templates). Fall back to the stable record id so
-        # every template gets a unique, deterministic suffix. Resolved lazily so an
-        # unsupported record (no #id) still falls through to the ArgumentError in the
-        # caller. The identifier is shortened to its first UUID group (8 hex chars).
-        # A segment's <element> is the name of the ElementKlass it belongs to.
-        identifier = lambda do
-          raw = record.try(:identifier).presence || record.try(:uuid).presence || record.id
-          raw.to_s.split('-').first
-        end
-        case record
-        when ::Labimotion::ElementKlass
-          [LABIMOTION_DOI_NAMESPACE, 'element', record.name, identifier.call]
-        when ::Labimotion::SegmentKlass
-          [LABIMOTION_DOI_NAMESPACE, 'segment', record.element_klass&.name, identifier.call]
-        when ::Labimotion::DatasetKlass
-          [LABIMOTION_DOI_NAMESPACE, 'dataset', record.ols_term_id, identifier.call]
-        end
-      end
-
-      # Keeps a suffix segment DOI-safe: trims, collapses whitespace to hyphens and
-      # drops anything outside [A-Za-z0-9._-] (colons stripped, as elsewhere here).
-      def sanitize_doi_part(value)
-        value.to_s.strip.gsub(/\s+/, '-').gsub(/[^A-Za-z0-9._-]/, '')
-      end
-    end
-  end
-end