labimotion 2.2.0.rc9 → 2.2.0.rc11

data/README.md

@@ -0,0 +1,68 @@
+# LabIMotion [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3755759.svg)](https://doi.org/10.5281/zenodo.8305411)
+
+LabIMotion is a software that offers the flexibility to design new modules tailored to the specific needs of the scientists.
+Generic elements, segments, and datasets are organized using Components, which are introduced as layers and fields. Each generic element, segment, or dataset can include multiple layers, with the potential for multiple fields within each layer. This hierarchical structure enables a flexible and comprehensive organization of data and information.
+
+
+
+![Design Principles](https://www.chemotion.net/assets/images/generic_feature_outline-a58eee8e02ca7247e54f7ad17ee2c102.png)
+
+
+## Version 1.0.18 of LabIMotion, featuring:
+
+* Generic Designer
+* Workflow of Generic Element
+* Repetitation of layers
+* Drag Element to Element
+* Dataset Metadata
+* LabIMotion Template Hub Synchronization [**[LabIMotion Template Hub]**]
+
+---
+
+This repository contains a backend service for the LabIMotion. It is written in **[Ruby]**.
+
+### Community
+
+  * [GitHub discussions](https://github.com/labimotion/labimotion/discussions)
+  
+### Code
+
+  * [GitHub code](https://github.com/labimotion/labimotion) and [bug tracker](https://github.com/labimotion/labimotion/issues)
+
+---
+
+
+## Documentation
+
+Documentation for users **⸢ [Documentation] ⸥**
+
+Documentation for developers **⸢ [Technical Documentation] ⸥**
+
+---
+
+## License
+
+Code released under the [AGPL-3.0 License]([https://www.gnu.org/licenses/agpl-3.0.txt](https://www.gnu.org/licenses/agpl-3.0.txt)).
+
+---
+
+## Acknowledgments
+
+This project has been funded by the **[DFG]**.
+
+[![DFG Logo]][DFG]
+
+
+Funded by the [Deutsche Forschungsgemeinschaft (DFG, German Research Foundation)](https://www.dfg.de/) under the [National Research Data Infrastructure – NFDI4Chem](https://nfdi4chem.de/) – Projektnummer **441958208** since 2020.
+
+
+
+<!----------------------------------------------------------------------------->
+[Documentation]: https://www.chemotion.net/docs/labimotion/
+[Technical Documentation]: https://www.rubydoc.info/gems/labimotion
+[DFG]: https://www.dfg.de/en/
+[DFG Logo]: https://www.dfg.de/zentralablage/bilder/service/logos_corporate_design/logo_negativ_267.png
+[Nicole Jung]: mailto:nicole.jung@kit.edu
+[Karlsruhe Institute of Technology]: https://www.kit.edu/english/
+[Ruby]: https://www.ruby-lang.org/
+[LabIMotion Template Hub]: https://www.chemotion-repository.net/home/genericHub

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

@@ -12,8 +12,11 @@ module Labimotion
     mount Labimotion::LabimotionHubAPI
     mount Labimotion::StandardLayerAPI
     mount Labimotion::VocabularyAPI
+    mount Labimotion::UserAPI
     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/apis/user_api.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'labimotion/version'
+
+module Labimotion
+  # User API
+  class UserAPI < Grape::API
+    helpers Labimotion::ParamHelpers
+    helpers Labimotion::GenericHelpers
+
+    resource :limo do
+      resource :users do
+        namespace :list do
+          desc 'List users by keyword'
+          params do
+            requires :name, type: String, desc: 'Keyword'
+            optional :limit, type: Integer, default: 5, desc: 'Limit (max 10)'
+            optional :type, type: String, default: 'Person', desc: 'User type'
+          end
+          get do
+            error!('401 Unauthorized', 401) unless current_user
+            return { mc: 'ss00', msg: 'Entered name too short', data: [] } if params[:name].to_s.length < 3
+
+            query = 'first_name ILIKE :q OR last_name ILIKE :q OR name ILIKE :q OR name_abbreviation ILIKE :q'
+            users = User.where(query, q: "%#{params[:name]}%")
+                        .where(type: params[:type])
+                        .limit([params[:limit].to_i, 10].min)
+            data = Labimotion::UserEntity.represent(users)
+            { mc: 'ss00', data: data }
+          rescue StandardError => e
+            Labimotion.log_exception(e, current_user)
+            { mc: 'se00', msg: e.message, data: [] }
+          end
+        end
+
+        desc 'Get user info by id'
+        params do
+          requires :id, type: Integer, desc: 'User id'
+        end
+        route_param :id do
+          get do
+            error!('401 Unauthorized', 401) unless current_user
+            user = User.find(params[:id])
+            data = Labimotion::UserEntity.represent(user)
+            { mc: 'ss00', data: data }
+          rescue ActiveRecord::RecordNotFound
+            error!('404 Not Found', 404)
+          rescue StandardError => e
+            Labimotion.log_exception(e, current_user)
+            { mc: 'se00', msg: e.message, data: {} }
+          end
+        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/entities/user_entity.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'labimotion/entities/application_entity'
+module Labimotion
+  # User entity
+  class UserEntity < Labimotion::ApplicationEntity
+    expose :id, :email, :first_name, :last_name, :name, :name_abbreviation
+  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/libs/converter.rb

@@ -125,7 +125,8 @@ module Labimotion
         tmp_file.rewind
 
         filename = oat.filename
-        name = "#{File.basename(filename, '.*')}.zip"
+        # name = "#{File.basename(filename, '.*')}.zip"
+        name = "#{File.basename(filename, '.*')}#{File.extname(filename) == '.zip' ? '.bagit.zip' : '.zip'}"
         att = Attachment.new(
           filename: name,
           file_path: tmp_file.path,

data/lib/labimotion/libs/nmr_mapper.rb

@@ -34,7 +34,7 @@ module Labimotion
         return Labimotion::ConState::NONE if att.nil?
 
         result = process(att)
-        return Labimotion::ConState::NONE if result.nil?
+        return Labimotion::ConState::WAIT if result.nil?
 
         handle_process_result(result, att, id, current_user)
       end
@@ -136,7 +136,7 @@ module Labimotion
         if result[:is_bagit]
           handle_bagit_result(att, id, current_user)
         elsif invalid_metadata?(result)
-          Labimotion::ConState::NONE
+          Labimotion::ConState::WAIT
         else
           handle_nmr_result(result, att, current_user)
         end

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

@@ -31,6 +31,7 @@ module Labimotion
         case con_state
         when Labimotion::ConState::NMR
           self.con_state = Labimotion::NmrMapper.process_ds(id, current_user)
+          return exec_converter if con_state == Labimotion::ConState::WAIT
           update_column(:con_state, con_state)
         when Labimotion::ConState::WAIT
           self.con_state = Labimotion::Converter.jcamp_converter(id, current_user)

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/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/version.rb

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

data/lib/labimotion.rb

@@ -27,9 +27,12 @@ module Labimotion
   autoload :ExporterAPI, 'labimotion/apis/exporter_api'
   autoload :StandardLayerAPI, 'labimotion/apis/standard_layer_api'
   autoload :VocabularyAPI, 'labimotion/apis/vocabulary_api'
+  autoload :UserAPI, 'labimotion/apis/user_api'
   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'
@@ -52,7 +55,9 @@ module Labimotion
   autoload :SegmentRevisionEntity, 'labimotion/entities/segment_revision_entity'
   ## autoload :DatasetRevisionEntity, 'labimotion/entities/dataset_revision_entity'
   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'