labimotion 2.2.0.rc19 → 2.2.0.rc21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf9125138e1e1d1e52a978fd85f63e67dd1339cf683296bdf0680c86dd9cc16b
-  data.tar.gz: e910e27b0a70cc1e6995142a23af5fba0f59a9313bd13d5eea01092f42991c85
+  metadata.gz: 006f7a0d5c1bc994e1ed1be862881e579b83a91844e176858571471a4225a6e5
+  data.tar.gz: 9d40a31313cc7717bd0a9cb971e457bc6c2ad93a3818a3ad305dec05ad9bc406
 SHA512:
-  metadata.gz: ee02aa627ad14085e7860c8f017442d3733a764883781cd6e5156b5a4cd759b41a9697612fd37238437b4c7ef6671f5e43e355243c6cf70061ec555ebb46b7b8
-  data.tar.gz: de67299ee82e4e59b8dcce459265b3905338fef48c60271d86b653f00279a8e749afbeb5ea53681a2e0e2ca7a9c4a4386073ec9fe29f17f96504ff1a7ea9cf50
+  metadata.gz: 399cb835f06e3cc7e30a8c59f3e64ae7738da938a7bb4a68e3ffd9c331854e36c84743b90a07769407c910d2b49042996734d2572517932a97869a18f0e6174b
+  data.tar.gz: 8ce94d81213aba4205aff04328c3eba89ca095b84301ddf7eee22497e0964635a0998735175f47fa00642f4d47d481e9ef0aa95bb1b04357705a1c1ad21c3c6b

data/lib/labimotion/apis/generic_element_api.rb

@@ -432,6 +432,7 @@ 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,6 +7,8 @@ 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.
+    PUBLIC_PUBLICATION_KEYS = %w[title description authors contributor license].freeze
 
     helpers do
       def resolve_klass!(type, id)
@@ -41,25 +43,36 @@ module Labimotion
         )
       end
 
-      # Public, read-only view of one released DOI version.
-      def released_doi_version(doi)
+      # Public, read-only view of one released DOI version, carrying the
+      # publication metadata that version was released with.
+      def released_doi_version(record, 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
+          minted_at: doi.minted_at,
+          publication: released_publication(record, doi)
         }
       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. `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. 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.
       def released_template_doi(record, dois)
-        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 = dois.sort_by(&:id).map { |doi| released_doi_version(record, doi) }
         versions.last.merge(
           record_id: record.try(:identifier).presence || record.try(:uuid).presence || record.id,
           identifier: record.try(:identifier),
@@ -68,7 +81,6 @@ 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
@@ -125,7 +137,7 @@ module Labimotion
                 version: ::Doi.labimotion_doi_version(doi),
                 full_doi: doi.full_doi,
                 minted: doi.minted == true,
-                xml: Labimotion::BuildTemplateDoiXml.new(record, doi, current_user).call
+                xml: Labimotion::BuildTemplateDoiXml.new(record, doi).call
               }
             end
             { versions: versions }

data/lib/labimotion/apis/labimotion_template_browse_api.rb

@@ -9,6 +9,8 @@ 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.
+    PUBLICATION_KEYS = %w[title description authors contributor license].freeze
     # type => [revision model, foreign key to the klass]
     REVISION_BY_TYPE = {
       'element' => [::Labimotion::ElementKlassesRevision, :element_klass_id],
@@ -76,7 +78,14 @@ 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('title', 'description', 'authors', 'license') : {}
+        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)
       end
 
       # Released (minted) DOIs of the template, each tagged with its DOI version
@@ -88,6 +97,7 @@ 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,21 +247,27 @@ module Labimotion
     end
 
     def list_serialized_elements(params, current_user)
-      scope = Labimotion::Element.none
-
+      collection_id =
       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
+        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 =
+      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)
       else
-        # All collection of current_user
-        scope = Labimotion::Element.for_user(current_user.id)
+        Labimotion::Element.none
       end
 
       ## TO DO: refactor labimotion
@@ -272,7 +278,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 records
+        # Shared (synced) records
         shared = apply_filters.call(
-          left_joins(:collection_shares).where(collection_shares: { shared_with_id: user_id })
+          joins(collections: :sync_collections_users).where(sync_collections_users: { user_id: user_id })
         )
 
         # Combine (remove duplicates), order, and limit

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

@@ -82,6 +82,26 @@ module Labimotion
         { '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

data/lib/labimotion/models/element.rb

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

data/lib/labimotion/usecases/build_template_doi_xml.rb

@@ -23,10 +23,9 @@ module Labimotion
       'dataset' => 'LabIMotion Dataset Template'
     }.freeze
 
-    def initialize(record, doi = nil, current_user = nil)
+    def initialize(record, doi = 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.
@@ -89,23 +88,31 @@ module Labimotion
       end
     end
 
-    # The acting user, rendered as a DataCite "Researcher" contributor. Nil
-    # (no contributors block) when there is no user or they have no name.
+    # The author picked from the author list, rendered as a DataCite
+    # "Researcher" contributor. Nil (no contributors block) when none has been
+    # picked — it is never inferred from whoever happens to be publishing.
     def contributor
-      user = @current_user
-      return nil unless user
+      picked = publication['contributor']
+      return nil unless picked.is_a?(Hash)
 
-      given = user.try(:first_name).to_s.strip
-      family = user.try(:last_name).to_s.strip
+      given = picked['givenName'].to_s.strip
+      family = picked['familyName'].to_s.strip
       return nil if given.empty? && family.empty?
 
-      orcid = user.respond_to?(:orcid) ? user.orcid.to_s.strip : ''
-      { 'givenName' => h(given), 'familyName' => h(family), 'orcid' => h(orcid) }
+      { 'givenName' => h(given), 'familyName' => h(family), 'orcid' => h(picked['orcid'].to_s.strip) }
     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 ||=
-        (@record.properties_template.is_a?(Hash) ? @record.properties_template['publication'] : nil) || {}
+      @publication ||= ::Doi.labimotion_doi_publication(@doi).presence || record_publication
+    end
+
+    def record_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,7 +24,8 @@ module Labimotion
       return failure('doi not reserved') if @doi.nil?
       return self if @doi.minted
 
-      return failure('publication metadata is incomplete') unless metadata_ready?
+      missing = missing_metadata
+      return failure("publication metadata is incomplete: #{missing.join(', ')}") if missing.any?
 
       publish_at_datacite
       self
@@ -37,22 +38,33 @@ module Labimotion
     private
 
     def publish_at_datacite
-      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
+      datacite_failure = send_to_datacite? ? mint_at_datacite : nil
+      return failure(datacite_failure) if datacite_failure
 
       ActiveRecord::Base.transaction do
-        doi.update!(minted: true, minted_at: Time.current)
+        # 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))
         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})"
@@ -73,13 +85,27 @@ module Labimotion
       record.update!(attrs) if attrs.any?
     end
 
-    def metadata_ready?
-      publication = record.properties_template.is_a?(Hash) ? record.properties_template['publication'] : nil
-      return false unless publication.is_a?(Hash)
+    # Everything the publication form owns that DataCite needs, named so the
+    # modal can say what is still missing. The contributor is one of the
+    # authors and has to be picked in the form — a DOI is never released
+    # crediting whoever happened to press the button.
+    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 << 'contributor' unless named?(publication['contributor'])
+      missing
+    end
+
+    def named?(person)
+      person.is_a?(Hash) && person['familyName'].to_s.strip.present?
+    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? }
+    # 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
     end
 
     def failure(message)

data/lib/labimotion/usecases/update_template_publication_metadata.rb

@@ -7,7 +7,7 @@ module Labimotion
   class UpdateTemplatePublicationMetadata
     include TemplateDoiHelpers
 
-    ALLOWED_KEYS = %w[title description authors license].freeze
+    ALLOWED_KEYS = %w[title description authors contributor license].freeze
 
     attr_reader :record, :current_user, :publication, :error
 
@@ -39,9 +39,33 @@ module Labimotion
     def normalized_publication
       slice = publication.stringify_keys.slice(*ALLOWED_KEYS)
       slice['authors'] = Array(slice['authors']).filter_map { |a| normalize_author(a) }
+      picked = picked_contributor(slice['authors'], slice['contributor'])
+      picked ? slice['contributor'] = picked : slice.delete('contributor')
       slice
     end
 
+    # The contributor is one of the authors, so it is matched back against the
+    # saved author list and stored as that author. Anything that matches none
+    # of them — a stale pick whose author has since been removed, or a name
+    # that was never on the list — is dropped.
+    def picked_contributor(authors, contributor)
+      picked = normalize_author(contributor)
+      return nil if picked.nil?
+
+      authors.find { |author| same_person?(author, picked) }
+    end
+
+    # ORCID identifies a person when both sides carry one; otherwise fall back
+    # to the name pair, which is what the editor matches on too.
+    def same_person?(one, other)
+      orcids = [one, other].map { |a| a['orcid'].to_s.strip }
+      return orcids[0].casecmp?(orcids[1]) if orcids.all?(&:present?)
+
+      %w[givenName familyName].all? do |key|
+        one[key].to_s.strip.casecmp?(other[key].to_s.strip)
+      end
+    end
+
     def normalize_author(author)
       return nil unless author.is_a?(Hash)
 

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.accessible_for(current_user).find(c_id)
+      collection = Collection.belongs_to_or_shared_by(current_user.id, current_user.group_ids).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.accessible_for(current_user).find(c_id)
+      collection = Collection.belongs_to_or_shared_by(current_user.id, current_user.group_ids).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/version.rb

@@ -2,5 +2,5 @@
 
 ## Labimotion Version
 module Labimotion
-  VERSION = '2.2.0.rc19'
+  VERSION = '2.2.0.rc21'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.2.0.rc19
+  version: 2.2.0.rc21
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-07-27 00:00:00.000000000 Z
+date: 2026-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: caxlsx