labimotion 2.2.0.rc10 → 2.2.0.rc12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 727f612dabb886b6189d747d61c391b6ccae83ebd2279a3961d38b652449b7e8
-  data.tar.gz: 9d94f4337c5d28f44cba194e45bac135a715a0d193254f5792049b688801d734
+  metadata.gz: 407197c03e88402882b081d31dc92999629ec43c25b8c056c6f6ba3ca40135fc
+  data.tar.gz: d331368ce985ae7ff32a98f0747e9b06233eb5ac3b9b1a0c17e76a3ecbeeab7a
 SHA512:
-  metadata.gz: 64a75edfdc0efee53dca7bf8c03aa2747fc9cf0672723056e97a80989ca23ed03fb32700af3f38d6ebd80d757398250868bfdceb9458288ea77e4e78d79b8e8a
-  data.tar.gz: 1e594266697dd026612ba27d6f7df1566f7f8dc696c8d18ce318a35ccdfc9eaf3c6b0e0467daf9e0601253f0bcc4d78c5bbb7a624319300b6b9a091db1f6de06
+  metadata.gz: 275089d4170573e9961387dfe2274e9c5c8d1f9ccfe02b854aec3b1a5bfb237f5535915fd73205fc1efa564102ef33605a4f5de148fec8244b76ee2ca9fa5b48
+  data.tar.gz: 75b3433050aab3b9a76c9442643b0c5dcb87b508672d4b3b1c57b8ca52bbb75e1045cf429c25c4cfa64616df2482baa15062ccc45f515173012f31ca6cbcacef

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_api.rb

@@ -16,5 +16,7 @@ module Labimotion
     mount Labimotion::MttAPI
     mount Labimotion::DoseRespRequestAPI
     mount Labimotion::ElementVariationAPI
+    mount Labimotion::LabimotionDoiAPI
+    mount Labimotion::LabimotionTemplateBrowseAPI
   end
 end

data/lib/labimotion/apis/labimotion_doi_api.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # DOI lifecycle (reserve + release) and publication metadata for
+  # LabIMotion templates: ElementKlass / SegmentKlass / DatasetKlass.
+  class LabimotionDoiAPI < Grape::API
+    # rubocop:disable Metrics/BlockLength
+    # Grape route and helper DSL blocks are necessarily large.
+    KLASS_TYPES = ::Usecases::Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE.keys.freeze
+
+    helpers do
+      def resolve_klass!(type, id)
+        model = ::Usecases::Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE[type]
+        error!('unknown template type', 404) unless model
+
+        record = model.find_by(id: id)
+        error!('template not found', 404) unless record
+
+        record
+      end
+
+      def render_template_doi(record)
+        type = ::Usecases::Labimotion::TemplateDoiHelpers.klass_type_for(record)
+        dois = ::Doi.labimotion_dois(record)
+        # `doi` is the current (most recently reserved) DOI; `released_doi` is the
+        # latest released (minted) one. They differ once a new version has been
+        # reserved on top of a released one, so the modal can show both at once.
+        doi = dois.last
+        released_doi = dois.reverse.find(&:minted)
+        Labimotion::LabimotionTemplateDoiEntity.represent(
+          type: type,
+          klass_id: record.id,
+          doi: doi,
+          released_doi_version: released_doi && ::Doi.labimotion_doi_version(released_doi),
+          publication: (record.properties_template || {})['publication'],
+          released_at: record.released_at,
+          released_by: record.released_by,
+          new_version_available: ::Usecases::Labimotion::TemplateDoiHelpers.new_version_available?(record),
+          next_doi_version: ::Doi.labimotion_version_segment(record),
+          template_url: ::Usecases::Labimotion::TemplateDoiHelpers.template_url(record)
+        )
+      end
+
+      # 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
+        }
+      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.
+      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.last.merge(
+          record_id: record.try(:identifier).presence || record.try(:uuid).presence || record.id,
+          identifier: record.try(:identifier),
+          uuid: record.try(:uuid),
+          label: record.try(:label),
+          template_version: record.try(:version),
+          next_doi_version: ::Doi.labimotion_version_segment(record),
+          template_url: ::Usecases::Labimotion::TemplateDoiHelpers.template_url(record),
+          publication: publication,
+          versions: versions
+        )
+      end
+    end
+
+    namespace :labimotion_doi do
+      # Public, anonymous read-only DOI info for the LabIMotion Template Hub.
+      # Whitelisted in RepoAPI::PUBLIC_URLS so it bypasses authenticate!; only
+      # released (minted) DOIs and their public publication metadata are exposed.
+      namespace :public do
+        route_param :type, type: String, values: KLASS_TYPES do
+          desc 'Released DOIs + publication metadata for every released template of a type'
+          get :released do
+            model = ::Usecases::Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE[params[:type]]
+            grouped = ::Doi.where(doiable_type: model.name).where.not(minted_at: nil)
+                           .order(:id).group_by(&:doiable_id)
+            records = model.where(id: grouped.keys).index_by(&:id)
+            released = grouped.filter_map do |klass_id, dois|
+              record = records[klass_id]
+              record && released_template_doi(record, dois)
+            end
+            { released_dois: released }
+          end
+        end
+      end
+
+      route_param :type, type: String, values: KLASS_TYPES do
+        desc "DOI state (reserved / released) per template of a type, for the designer grid's DOI icon"
+        get :states do
+          model = ::Usecases::Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE[params[:type]]
+          grouped = ::Doi.where(doiable_type: model.name).order(:id).group_by(&:doiable_id)
+          states = grouped.transform_values do |list|
+            released = list.last.minted == true
+            { reserved: !released, released: released }
+          end
+          { states: states }
+        end
+
+        route_param :id, type: Integer do
+          desc 'Returns the current DOI/publication state for a template'
+          get do
+            record = resolve_klass!(params[:type], params[:id])
+            render_template_doi(record)
+          end
+
+          desc "Returns the DataCite metadata XML for every one of the template's DOI versions"
+          get :metadata_xml do
+            record = resolve_klass!(params[:type], params[:id])
+            dois = ::Doi.labimotion_dois(record)
+            error!('no DOI reserved', 404) if dois.empty?
+
+            versions = dois.map do |doi|
+              {
+                version: ::Doi.labimotion_doi_version(doi),
+                full_doi: doi.full_doi,
+                minted: doi.minted == true,
+                xml: ::Usecases::Labimotion::BuildTemplateDoiXml.new(record, doi, current_user).call
+              }
+            end
+            { versions: versions }
+          end
+
+          desc 'Updates the publication metadata of a template'
+          params do
+            requires :publication, type: Hash
+          end
+          put :publication_metadata do
+            record = resolve_klass!(params[:type], params[:id])
+            uc = ::Usecases::Labimotion::UpdateTemplatePublicationMetadata.new(
+              record, current_user, params[:publication]
+            ).call
+            error!(uc.error, 422) unless uc.success?
+
+            render_template_doi(record.reload)
+          end
+
+          desc 'Reserves a DataCite DOI for a template'
+          post :reserve_doi do
+            record = resolve_klass!(params[:type], params[:id])
+            uc = ::Usecases::Labimotion::ReserveTemplateDoi.new(record, current_user).call
+            error!(uc.error, 422) unless uc.success?
+
+            render_template_doi(record.reload)
+          end
+
+          desc 'Releases (mints) the reserved DOI for a template'
+          post :release_doi do
+            record = resolve_klass!(params[:type], params[:id])
+            uc = ::Usecases::Labimotion::ReleaseTemplateDoi.new(record, current_user).call
+            error!(uc.error, 422) unless uc.success?
+
+            render_template_doi(record.reload)
+          end
+        end
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end

data/lib/labimotion/apis/labimotion_template_browse_api.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Public, read-only browsing of released LabIMotion templates for the Template
+  # Hub "Find a Template" tab: pick a type, a template, then a release version.
+  # Returns every released version (revision) of one template, each with its own
+  # properties_release so the frontend can render the example inline.
+  # Whitelisted in RepoAPI::PUBLIC_URLS so anonymous hub visitors can use it.
+  class LabimotionTemplateBrowseAPI < Grape::API
+    KLASS_BY_TYPE = ::Usecases::Labimotion::TemplateDoiHelpers::KLASS_BY_TYPE
+    KLASS_TYPES = KLASS_BY_TYPE.keys.freeze
+    # type => [revision model, foreign key to the klass]
+    REVISION_BY_TYPE = {
+      'element' => [::Labimotion::ElementKlassesRevision, :element_klass_id],
+      'segment' => [::Labimotion::SegmentKlassesRevision, :segment_klass_id],
+      'dataset' => [::Labimotion::DatasetKlassesRevision, :dataset_klass_id]
+    }.freeze
+
+    # rubocop:disable Metrics/BlockLength
+    # The helpers block is large due to the many template/version/DOI shaping helpers.
+    helpers do
+      def find_template(model, identifier)
+        model.find_by(identifier: identifier) || model.find_by(uuid: identifier)
+      end
+
+      # Numeric sort key for a "major.minor" version string.
+      def version_sort_key(version)
+        version.to_s.split('.').map(&:to_i)
+      end
+
+      def template_summary(record, type)
+        element_klass = record.try(:element_klass)
+        {
+          type: type,
+          identifier: record.try(:identifier),
+          uuid: record.try(:uuid),
+          name: record.try(:name),
+          label: record.try(:label),
+          desc: record.try(:desc),
+          klass_prefix: record.try(:klass_prefix),
+          icon_name: record.try(:icon_name),
+          current_version: record.try(:version),
+          element_klass: element_klass && { label: element_klass.label, icon_name: element_klass.icon_name }
+        }
+      end
+
+      def version_entry(version, released_at, uuid, properties_release)
+        { version: version, released_at: released_at, uuid: uuid, properties_release: properties_release }
+      end
+
+      # The current klass's released version is appended only when no revision
+      # already captures it, so the latest is always selectable.
+      def append_current?(record, versions)
+        record.try(:released_at).present? && versions.none? { |v| v[:version] == record.try(:version) }
+      end
+
+      # Drops blank-version entries and orders newest-first.
+      def sort_versions(versions)
+        versions.reject { |v| v[:version].to_s.strip.empty? }
+                .sort_by { |v| version_sort_key(v[:version]) }.reverse
+      end
+
+      # All released versions of a template, newest first. Built from the
+      # revision snapshots, plus the current klass (see append_current?).
+      def released_versions(record, type)
+        rev_model, foreign_key = REVISION_BY_TYPE[type]
+        scope = rev_model.where(foreign_key => record.id).where.not(released_at: nil)
+        versions = scope.map { |rev| version_entry(rev.version, rev.released_at, rev.uuid, rev.properties_release) }
+        if append_current?(record, versions)
+          versions << version_entry(record.try(:version), record.released_at,
+                                    record.try(:uuid), record.try(:properties_release))
+        end
+        sort_versions(versions)
+      end
+
+      # 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') : {}
+      end
+
+      # Released (minted) DOIs of the template, each tagged with its DOI version
+      # and its DataCite (kernel-4) metadata XML (the downloadable DOI metadata).
+      # The frontend maps a chosen template version to the applicable DOI version
+      # and shows/downloads the matching entry.
+      def released_dois(record)
+        ::Doi.labimotion_dois(record).select(&:minted).map do |doi|
+          full = doi.full_doi
+          { version: ::Doi.labimotion_doi_version(doi), doi: full,
+            doi_url: "https://dx.doi.org/#{full}", minted_at: doi.minted_at,
+            xml: ::Usecases::Labimotion::BuildTemplateDoiXml.new(record, doi).call }
+        end
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+
+    namespace :labimotion_template_browse do
+      route_param :type, type: String, values: KLASS_TYPES do
+        desc 'Released versions (revisions) of one template, each with properties_release'
+        params do
+          requires :identifier, type: String, desc: 'template identifier or uuid'
+        end
+        get :versions do
+          model = KLASS_BY_TYPE[params[:type]]
+          error!('unknown template type', 404) unless model
+
+          record = find_template(model, params[:identifier])
+          error!('template not found', 404) unless record
+
+          {
+            template: template_summary(record, params[:type]),
+            versions: released_versions(record, params[:type]),
+            dois: released_dois(record),
+            publication: template_publication(record)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/labimotion/entities/labimotion_template_doi_entity.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Labimotion
+  # Serializes the DOI + publication state for a LabIMotion template
+  # (ElementKlass / SegmentKlass / DatasetKlass). Built ad-hoc by
+  # Labimotion::LabimotionDoiAPI; not a direct AR record entity.
+  class LabimotionTemplateDoiEntity < Grape::Entity
+    expose :type
+    expose :klass_id
+    expose :doi do |obj|
+      next nil unless obj[:doi]
+
+      {
+        id: obj[:doi].id,
+        suffix: obj[:doi].suffix,
+        full_doi: obj[:doi].full_doi,
+        version: ::Doi.labimotion_doi_version(obj[:doi]),
+        minted: obj[:doi].minted == true,
+        minted_at: obj[:doi].minted_at
+      }
+    end
+    expose :released_doi_version
+    expose :publication
+    expose :released_at
+    expose :released_by
+    expose :new_version_available
+    expose :next_doi_version
+    expose :template_url
+  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/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/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.rc10'
+  VERSION = '2.2.0.rc12'
 end

data/lib/labimotion.rb

@@ -31,6 +31,8 @@ module Labimotion
   autoload :MttAPI, 'labimotion/apis/mtt_api'
   autoload :DoseRespRequestAPI, 'labimotion/apis/dose_resp_request_api'
   autoload :ElementVariationAPI, 'labimotion/apis/element_variation_api'
+  autoload :LabimotionDoiAPI, 'labimotion/apis/labimotion_doi_api'
+  autoload :LabimotionTemplateBrowseAPI, 'labimotion/apis/labimotion_template_browse_api'
 
   ######## Entities
   autoload :PropertiesEntity, 'labimotion/entities/properties_entity'
@@ -55,6 +57,7 @@ module Labimotion
   autoload :VocabularyEntity, 'labimotion/entities/vocabulary_entity'
   autoload :UserEntity, 'labimotion/entities/user_entity'
   autoload :ElementVariationEntity, 'labimotion/entities/element_variation_entity'
+  autoload :LabimotionTemplateDoiEntity, 'labimotion/entities/labimotion_template_doi_entity'
 
   ######## Helpers
   autoload :GenericHelpers, 'labimotion/helpers/generic_helpers'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.2.0.rc10
+  version: 2.2.0.rc12
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-19 00:00:00.000000000 Z
+date: 2026-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: caxlsx
@@ -65,7 +65,9 @@ files:
 - lib/labimotion/apis/generic_element_api.rb
 - lib/labimotion/apis/generic_klass_api.rb
 - lib/labimotion/apis/labimotion_api.rb
+- lib/labimotion/apis/labimotion_doi_api.rb
 - lib/labimotion/apis/labimotion_hub_api.rb
+- lib/labimotion/apis/labimotion_template_browse_api.rb
 - lib/labimotion/apis/mtt_api.rb
 - lib/labimotion/apis/segment_api.rb
 - lib/labimotion/apis/standard_api.rb
@@ -88,6 +90,7 @@ files:
 - lib/labimotion/entities/generic_klass_entity.rb
 - lib/labimotion/entities/generic_public_entity.rb
 - lib/labimotion/entities/klass_revision_entity.rb
+- lib/labimotion/entities/labimotion_template_doi_entity.rb
 - lib/labimotion/entities/properties_entity.rb
 - lib/labimotion/entities/segment_entity.rb
 - lib/labimotion/entities/segment_klass_entity.rb