labimotion 0.1.6

data/lib/labimotion/utils/import.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class Import
+
+    def self.import_repo_segment_props(instances, attachments, attachable_uuid, fields)
+      primary_store = Rails.configuration.storage.primary_store
+      attachable = instances.fetch('Labimotion::Segment').fetch(attachable_uuid)
+      attachment = Attachment.where(id: attachments, filename: fields.fetch('identifier')).first
+      attachment.update!(
+        attachable_id: attachable.id,
+        attachable_type: 'SegmentProps',
+        con_state: Labimotion::ConState::NONE,
+        transferred: true,
+        aasm_state: fields.fetch('aasm_state'),
+        filename: fields.fetch('filename'),
+        content_type: fields.fetch('content_type'),
+        storage: primary_store
+        # checksum: fields.fetch('checksum'),
+        # created_at: fields.fetch('created_at'),
+        # updated_at: fields.fetch('updated_at')
+      )
+
+      properties = attachable.properties
+      properties['layers'].keys.each do |key|
+        layer = properties['layers'][key]
+        field_uploads = layer['fields'].select { |ss| ss['type'] == 'upload' }
+        field_uploads&.each do |upload|
+          idx = properties['layers'][key]['fields'].index(upload)
+          files = upload["value"] && upload["value"]["files"]
+          files&.each_with_index do |fi, fdx|
+            if properties['layers'][key]['fields'][idx]['value']['files'][fdx]['uid'] == fields.fetch('identifier')
+              properties['layers'][key]['fields'][idx]['value']['files'][fdx]['aid'] = attachment.id
+              properties['layers'][key]['fields'][idx]['value']['files'][fdx]['uid'] = attachment.identifier
+            end
+          end
+        end
+      end
+      attachable.update!(properties: properties)
+      attachment
+    end
+
+    def self.import_datasets(data, instances, gt, current_user_id, &update_instances)
+      begin
+        data.fetch('Labimotion::Dataset', {}).each do |uuid, fields|
+          klass_id = fields['dataset_klass_id']
+          dk_obj = data.fetch('Labimotion::DatasetKlass', {})[klass_id]
+          dk_id = dk_obj['identifier']
+          element_uuid = fields.fetch('element_id')
+          element_type = fields.fetch('element_type')
+          element = instances.fetch(element_type).fetch(element_uuid)
+
+          dataset_klass = Labimotion::DatasetKlass.find_by(identifier: dk_id)
+          next if gt == true && dataset_klass.nil?
+
+          dkr = Labimotion::DatasetKlassesRevision.find_by(uuid: fields.fetch('klass_uuid'))
+          dataset_klass = dkr.dataset_klass if dataset_klass.nil? && dkr.present?
+          next if dataset_klass.nil? || dataset_klass.ols_term_id != dk_obj['ols_term_id']
+
+          dataset_klass = Labimotion::DatasetKlass.find_by(ols_term_id: dk_obj['ols_term_id']) if dataset_klass.nil?
+          next if dataset_klass.nil?
+
+          dataset = Labimotion::Dataset.create!(
+            fields.slice(
+              'properties', 'properties_release'
+            ).merge(
+              ## created_by: current_user_id,
+              element: element,
+              dataset_klass: dataset_klass,
+              uuid: SecureRandom.uuid,
+              klass_uuid: dkr&.uuid || dataset_klass.uuid
+            )
+          )
+          update_instances.call(uuid, dataset)
+        end
+      rescue StandardError => e
+        Rails.logger.error(e.backtrace)
+        raise
+      end
+    end
+
+    def self.import_segments(data, instances, gt, current_user_id, &update_instances)
+      begin
+        data.fetch('Labimotion::Segment', {}).each do |uuid, fields|
+          klass_id = fields["segment_klass_id"]
+          sk_obj = data.fetch('Labimotion::SegmentKlass', {})[klass_id]
+          sk_id = sk_obj["identifier"]
+          ek_obj = data.fetch('Labimotion::ElementKlass').fetch(sk_obj["element_klass_id"])
+          element_klass = Labimotion::ElementKlass.find_by(name: ek_obj['name']) if ek_obj.present?
+          next if element_klass.nil? || ek_obj.nil? || ek_obj['is_generic'] == true
+          element_uuid = fields.fetch('element_id')
+          element_type = fields.fetch('element_type')
+          element = instances.fetch(element_type).fetch(element_uuid)
+          segment_klass = Labimotion::SegmentKlass.find_by(identifier: sk_id)
+          next if gt == true && segment_klass.nil?
+
+          skr = Labimotion::SegmentKlassesRevision.find_by(uuid: fields.fetch('klass_uuid'))
+          segment_klass = skr.segment_klass if segment_klass.nil? && skr.present?
+
+          # segment_klass = Labimotion::SegmentKlass.create!(sk_obj.slice(
+          #     'label',
+          #     'desc',
+          #     'properties_template',
+          #     'is_active',
+          #     'place',
+          #     'properties_release',
+          #     'uuid',
+          #     'identifier',
+          #     'sync_time'
+          #   ).merge(
+          #     element_klass: element_klass,
+          #     created_by: current_user_id,
+          #     released_at: DateTime.now
+          #   )
+          # ) if segment_klass.nil?
+
+          next if segment_klass.nil?
+
+          segment = Labimotion::Segment.create!(
+            fields.slice(
+              'properties', 'properties_release'
+            ).merge(
+              created_by: current_user_id,
+              element: element,
+              segment_klass: segment_klass,
+              uuid: SecureRandom.uuid,
+              klass_uuid: skr&.uuid || segment_klass.uuid
+            )
+          )
+
+          properties = segment.properties
+          properties['layers'].keys.each do |key|
+            layer = properties['layers'][key]
+            field_molecules = layer['fields'].select { |ss| ss['type'] == 'drag_molecule' }
+            field_molecules.each do |field|
+              idx = properties['layers'][key]['fields'].index(field)
+              id = field["value"] && field["value"]["el_id"] unless idx.nil?
+              mol = Molecule.find_or_create_by_molfile(data.fetch('Molecule')[id]['molfile']) unless id.nil?
+              unless mol.nil?
+                properties['layers'][key]['fields'][idx]['value']['el_id'] = mol.id
+                properties['layers'][key]['fields'][idx]['value']['el_tip'] = "#{mol.inchikey}@@#{mol.cano_smiles}"
+                properties['layers'][key]['fields'][idx]['value']['el_label'] = mol.iupac_name
+              end
+            end
+
+            field_tables = layer['fields'].select { |ss| ss['type'] == 'table' }
+            field_tables&.each do |field|
+              tidx = layer['fields'].index(field)
+              next unless field['sub_values'].present? && field['sub_fields'].present?
+
+              field_table_molecules = field['sub_fields'].select { |ss| ss['type'] == 'drag_molecule' }
+              if field_table_molecules.present?
+                col_ids = field_table_molecules.map { |x| x.values[0] }
+                col_ids.each do |col_id|
+                  field['sub_values'].each_with_index do |sub_value, vdx|
+                    next unless sub_value[col_id].present? && sub_value[col_id]['value'].present? && sub_value[col_id]['value']['el_id'].present?
+
+                    svalue = sub_value[col_id]['value']
+                    next unless svalue['el_id'].present? && svalue['el_inchikey'].present?
+
+                    tmol = Molecule.find_or_create_by_molfile(data.fetch('Molecule')[svalue['el_id']]['molfile']) unless svalue['el_id'].nil?
+                    unless tmol.nil?
+                      properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_id'] = tmol.id
+                      properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_tip'] = "#{tmol.inchikey}@@#{tmol.cano_smiles}"
+                      properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_label'] = tmol.cano_smiles
+                      properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_smiles'] = tmol.cano_smiles
+                      properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_iupac'] = tmol.iupac_name
+                      properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_inchikey'] = tmol.inchikey
+                      properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_svg'] = File.join('/images', 'molecules', tmol.molecule_svg_file)
+                      properties['layers'][key]['fields'][tidx]['sub_values'][vdx][col_id]['value']['el_molecular_weight'] = tmol.molecular_weight
+                    end
+                  end
+                end
+              end
+            end
+          end
+          segment.update!(properties: properties)
+          update_instances.call(uuid, segment)
+        end
+      rescue StandardError => e
+        Rails.logger.error(e.backtrace)
+        raise
+      end
+    end
+  end
+end

data/lib/labimotion/utils/search.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class Search
+
+    def self.unique_element_layers(id)
+      Labimotion::ElementKlass.where(id: id).select("jsonb_object_keys((properties_release->>'layers')::jsonb) as keys").map(&:keys).uniq
+    end
+
+    def self.unique_segment_layers(id)
+      Labimotion::SegmentKlass.where(id: id).select("jsonb_object_keys((properties_release->>'layers')::jsonb) as keys").map(&:keys).uniq
+    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)
+      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?
+      if params[:selection][:searchProperties].present?
+        unique_layers = Labimotion::Search.unique_element_layers(params[:selection] && params[:selection][:genericKlassId])
+        params[:selection][:searchProperties] && params[:selection][:searchProperties][:layers] && params[:selection][:searchProperties][:layers].keys.each do |lk|
+          layer = params[:selection][:searchProperties][:layers][lk]
+          reg_layer = /^#{lk}$|(^#{lk}\.)/
+          uni_keys = unique_layers.select { |uni_key| uni_key.match(reg_layer) }
+          qs = layer[:fields].select { |f| f[:value].present? || f[:type] == 'input-group' }
+          qs.each do |f|
+            query_field = {}
+            if f[:type] == 'input-group'
+              sfs = f[:sub_fields].map { |e| { "id": e[:id], "value": e[:value] } }
+              query_field = { "fields": [{ "field": f[:field].to_s, "sub_fields": sfs }] } unless sfs.empty?
+            elsif %w[checkbox integer system-defined].include? f[:type]
+              query_field = { "fields": [{ "field": f[:field].to_s, "value": f[:value] }] }
+            elsif %w[drag_element drag_molecule drag_sample].include? f[:type]
+              vfs = { "el_label": f[:value] }
+              query_field = { "fields": [{ "field": f[:field].to_s, "value": vfs }] } unless f[:value].empty?
+            else
+              query_field = { "fields": [{ "field": f[:field].to_s, "value": f[:value].to_s }] }
+            end
+            next unless query_field.present?
+
+            sqls = []
+            uni_keys.select { |uni_key| uni_key.match(reg_layer) }.each do |e|
+              sql = ActiveRecord::Base.send(:sanitize_sql_array, ["(properties->'layers' @> ?)", { "#{e}": query_field }.to_json])
+              sqls = sqls.push(sql)
+            end
+            element_scope = element_scope.where(sqls.join(' OR '))
+          end
+        end
+      end
+      element_scope
+    end
+
+    def self.segments_search(ids, type)
+      eids = ids
+      seg_scope = Labimotion::Segment.where(element_type: type, element_id: ids)
+      if params[:selection][:segSearchProperties].present? && params[:selection][:segSearchProperties].length > 0
+        params[:selection][:segSearchProperties].each do |segmentSearch|
+          has_params = false
+          next unless segmentSearch[:id].present? && segmentSearch[:searchProperties].present? && segmentSearch[:searchProperties][:layers].present?
+          unique_layers = Labimotion::Search.unique_segment_layers(segmentSearch[:id])
+          segmentSearch[:searchProperties] && segmentSearch[:searchProperties][:layers] && segmentSearch[:searchProperties][:layers].keys.each do |lk|
+            layer = segmentSearch[:searchProperties][:layers][lk]
+            reg_layer = /^#{lk}$|(^#{lk}\.)/
+            uni_keys = unique_layers.select { |uni_key| uni_key.match(reg_layer) }
+            qs = layer[:fields].select { |f| f[:value].present? || f[:type] == 'input-group' }
+            qs.each do |f|
+              query_field = {}
+              if f[:type] == 'input-group'
+                sfs = f[:sub_fields].map { |e| { "id": e[:id], "value": e[:value] } }
+                query_field = { "fields": [{ "field": f[:field].to_s, "sub_fields": sfs }] } unless sfs.empty?
+              elsif %w[checkbox integer system-defined].include? f[:type]
+                query_field = { "fields": [{ "field": f[:field].to_s, "value": f[:value] }] }
+              elsif %w[drag_element drag_molecule drag_sample].include? f[:type]
+                vfs = { "el_label": f[:value] }
+                query_field = { "fields": [{ "field": f[:field].to_s, "value": vfs }] } unless f[:value].empty?
+              else
+                query_field = { "fields": [{ "field": f[:field].to_s, "value": f[:value].to_s }] }
+              end
+              next unless query_field.present?
+
+              has_params = true
+
+              sqls = []
+              uni_keys.select { |uni_key| uni_key.match(reg_layer) }.each do |e|
+                sql = ActiveRecord::Base.send(:sanitize_sql_array, ["(properties->'layers' @> ?)", { "#{e}": query_field }.to_json])
+                sqls = sqls.push(sql)
+              end
+              seg_scope = seg_scope.where(sqls.join(' OR '))
+            end
+          end
+          eids = (seg_scope.pluck(:element_id)) & eids if has_params == true
+        end
+      end
+      type.classify.constantize.where(id: eids)
+    end
+
+    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)
+      element_scope = Sample.joins(:collections_samples).where('collections_samples.collection_id = ?', collection.id)
+      return element_scope if sps.empty?
+
+      sps[:propCk].keys.each { |k| sqls.push(ActiveRecord::Base.send(:sanitize_sql_array, ["#{k} = (?)", sps[:propCk][k]])) if Sample.column_names.include?(k) } if sps[:propCk].present?
+      sps[:stereo].keys.each { |k| sqls.push(ActiveRecord::Base.send(:sanitize_sql_array, ['(stereo->> ? = ?)', k, sps[:stereo][k]])) } if sps[:stereo].present?
+      sps[:propTx].keys.each { |k| sqls = sqls.push(ActiveRecord::Base.send(:sanitize_sql, "#{k} like ('%#{sps[:propTx][k]}%')")) if Sample.column_names.include?(k) } if sps[:propTx].present?
+      element_scope = element_scope.where(sqls.join(' AND '))
+      element_scope
+    end
+
+  end
+end

data/lib/labimotion/utils/serializer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class Serializer
+    def self.set_table(field, field_table_objs, obj)
+      col_ids = field_table_objs.map { |x| x.values[0] }
+      col_ids.each do |col_id|
+        field['sub_values'].each do |sub_value|
+          next unless sub_value[col_id].present? && sub_value[col_id]['value'].present? && sub_value[col_id]['value']['el_id'].present?
+
+          find_obj = obj.constantize.find_by(id: sub_value[col_id]['value']['el_id'])
+          next unless find_obj.present?
+
+          case obj
+          when 'Molecule'
+            sub_value[col_id]['value']['el_svg'] = File.join('/images', 'molecules', find_obj.molecule_svg_file)
+            sub_value[col_id]['value']['el_inchikey'] = find_obj.inchikey
+            sub_value[col_id]['value']['el_smiles'] = find_obj.cano_smiles
+            sub_value[col_id]['value']['el_iupac'] = find_obj.iupac_name
+            sub_value[col_id]['value']['el_molecular_weight'] = find_obj.molecular_weight
+          when 'Sample'
+            sub_value[col_id]['value']['el_svg'] = find_obj.get_svg_path
+            sub_value[col_id]['value']['el_label'] = find_obj.short_label
+            sub_value[col_id]['value']['el_short_label'] = find_obj.short_label
+            sub_value[col_id]['value']['el_name'] = find_obj.name
+            sub_value[col_id]['value']['el_external_label'] = find_obj.external_label
+            sub_value[col_id]['value']['el_molecular_weight'] = find_obj.decoupled ? find_obj.molecular_mass : find_obj.molecule.molecular_weight
+            sub_value[col_id]['value']['el_decoupled'] = find_obj.decoupled
+          end
+        end
+      end
+      field
+    end
+
+    def self.element_properties(object)
+      object.properties['layers']&.keys.each do |key|
+        # layer = object.properties[key]
+        field_sample_molecules = object.properties['layers'][key]['fields'].select { |ss| %w[drag_sample drag_element drag_element].include?(ss['type']) }
+        field_sample_molecules.each do |field|
+          idx = object.properties['layers'][key]['fields'].index(field)
+          sid = field.dig('value') != '' && field.dig('value', 'el_id')
+          next unless sid.present?
+
+          case field['type']
+          when 'drag_sample'
+            el = Sample.find_by(id: sid)
+          when 'drag_molecule'
+            el = Molecule.find_by(id: sid)
+          when 'drag_element'
+            el = Labimotion::Element.find_by(id: sid)
+          end
+          next unless el.present?
+          next unless object.properties.dig('layers', key, 'fields', idx, 'value').present?
+
+          object.properties['layers'][key]['fields'][idx]['value']['el_label'] = el.short_label if %w[drag_sample drag_element].include?(field['type'])
+          object.properties['layers'][key]['fields'][idx]['value']['el_tip'] = el.short_label if %w[drag_sample].include?(field['type'])
+          object.properties['layers'][key]['fields'][idx]['value']['el_tip'] = "#{el.element_klass&.label}@@#{el.name}" if %w[drag_element].include?(field['type'])
+          object.properties['layers'][key]['fields'][idx]['value']['icon_name'] = el.element_klass&.icon_name || '' if %w[drag_element].include?(field['type'])
+          object.properties['layers'][key]['fields'][idx]['value']['el_svg'] = field['type'] == 'drag_sample' ? el.get_svg_path : File.join('/images', 'molecules', el.molecule_svg_file) if %w[drag_sample drag_molecule].include?(field['type'])
+          object.properties['layers'][key]['fields'][idx]['value']['el_decoupled'] = el.decoupled if %w[drag_sample].include?(field['type'])
+        end
+
+        field_tables = object.properties['layers'][key]['fields'].select { |ss| ss['type'] == 'table' }
+        field_tables.each do |field|
+          idx = object.properties['layers'][key]['fields'].index(field)
+          next unless field['sub_values'].present? && field['sub_fields'].present?
+
+          field_table_molecules = field['sub_fields'].select { |ss| ss['type'] == 'drag_molecule' }
+          object.properties['layers'][key]['fields'][idx] = set_table(field, field_table_molecules, 'Molecule') if field_table_molecules.present?
+
+          field_table_samples = field['sub_fields'].select { |ss| ss['type'] == 'drag_sample' }
+          object.properties['layers'][key]['fields'][idx] = set_table(field, field_table_samples, 'Sample') if field_table_samples.present?
+        end
+      end
+      object.properties
+    end
+  end
+end

data/lib/labimotion/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Labimotion
+  VERSION = '0.1.6'
+  IS_RAILS5 = true
+end

data/lib/labimotion.rb

@@ -0,0 +1,95 @@
+# In your_gem_name.rb or main Ruby file
+module Labimotion
+
+  autoload :VERSION, 'labimotion/version'
+
+  def self.logger
+    @@labimotion_logger ||= Logger.new(Rails.root.join('log/labimotion.log')) # rubocop:disable Style/ClassVars
+  end
+
+  def self.log_exception(exception, current_user = {})
+    Labimotion.logger.error("version: #{Labimotion::VERSION}; #{Labimotion::IS_RAILS5}, (#{current_user&.id}) \n Exception: #{exception.message}")
+    Labimotion.logger.error(exception.backtrace.join("\n"))
+  end
+
+
+  ######## APIs
+  autoload :GenericElementAPI, 'labimotion/apis/generic_element_api'
+  autoload :GenericDatasetAPI, 'labimotion/apis/generic_dataset_api'
+  autoload :SegmentAPI, 'labimotion/apis/segment_api'
+  autoload :LabimotionHubAPI, 'labimotion/apis/labimotion_hub_api'
+  autoload :ConverterAPI, 'labimotion/apis/converter_api'
+
+  ######## Entities
+  autoload :ElementEntity, 'labimotion/entities/element_entity'
+  autoload :ElnElementEntity, 'labimotion/entities/eln_element_entity'
+
+  autoload :SegmentEntity, 'labimotion/entities/segment_entity'
+  autoload :DatasetEntity, 'labimotion/entities/dataset_entity'
+
+  autoload :GenericKlassEntity, 'labimotion/entities/generic_klass_entity'
+  autoload :ElementKlassEntity, 'labimotion/entities/element_klass_entity'
+  autoload :SegmentKlassEntity, 'labimotion/entities/segment_klass_entity'
+  autoload :DatasetKlassEntity, 'labimotion/entities/dataset_klass_entity'
+
+  autoload :GenericEntity, 'labimotion/entities/generic_entity'
+  autoload :GenericPublicEntity, 'labimotion/entities/generic_public_entity'
+  autoload :KlassRevisionEntity, 'labimotion/entities/klass_revision_entity'
+  autoload :ElementRevisionEntity, 'labimotion/entities/element_revision_entity'
+  autoload :SegmentRevisionEntity, 'labimotion/entities/segment_revision_entity'
+  ## autoload :DatasetRevisionEntity, 'labimotion/entities/dataset_revision_entity'
+
+  ######## Helpers
+  autoload :GenericHelpers, 'labimotion/helpers/generic_helpers'
+  autoload :ElementHelpers, 'labimotion/helpers/element_helpers'
+  autoload :SegmentHelpers, 'labimotion/helpers/segment_helpers'
+  autoload :DatasetHelpers, 'labimotion/helpers/dataset_helpers'
+  autoload :SearchHelpers, 'labimotion/helpers/search_helpers'
+  autoload :ConverterHelpers, 'labimotion/helpers/converter_helpers'
+  autoload :SampleAssociationHelpers, 'labimotion/helpers/sample_association_helpers'
+  autoload :RepositoryHelpers, 'labimotion/helpers/repository_helpers'
+
+  ######## Libs
+  autoload :Converter, 'labimotion/libs/converter'
+  autoload :NmrMapper, 'labimotion/libs/nmr_mapper'
+  autoload :NmrMapperRepo, 'labimotion/libs/nmr_mapper_repo' ## for Chemotion Repository
+  autoload :TemplateHub, 'labimotion/libs/template_hub'
+  autoload :ExportDataset, 'labimotion/libs/export_dataset'
+
+  ######## Utils
+  autoload :ConState, 'labimotion/utils/con_state'
+  autoload :Serializer, 'labimotion/utils/serializer'
+  autoload :Search, 'labimotion/utils/search'
+  autoload :Export, 'labimotion/utils/export'
+  autoload :Import, 'labimotion/utils/import'
+
+  ######## Models
+  autoload :Element, 'labimotion/models/element'
+  autoload :Segment, 'labimotion/models/segment'
+  autoload :Dataset, 'labimotion/models/dataset'
+
+  autoload :ElementKlass, 'labimotion/models/element_klass'
+  autoload :SegmentKlass, 'labimotion/models/segment_klass'
+  autoload :DatasetKlass, 'labimotion/models/dataset_klass'
+
+  autoload :ElementsRevision, 'labimotion/models/elements_revision'
+  autoload :SegmentsRevision, 'labimotion/models/segments_revision'
+  autoload :DatasetsRevision, 'labimotion/models/datasets_revision'
+
+  autoload :ElementKlassesRevision, 'labimotion/models/element_klasses_revision'
+  autoload :SegmentKlassesRevision, 'labimotion/models/segment_klasses_revision'
+  autoload :DatasetKlassesRevision, 'labimotion/models/dataset_klasses_revision'
+
+  autoload :ElementsSample, 'labimotion/models/elements_sample'
+  autoload :ElementsElement, 'labimotion/models/elements_element'
+  autoload :CollectionsElement, 'labimotion/models/collections_element'
+
+  ######## Models/Concerns
+  autoload :GenericKlassRevisions, 'labimotion/models/concerns/generic_klass_revisions'
+  autoload :GenericRevisions, 'labimotion/models/concerns/generic_revisions'
+  autoload :Segmentable, 'labimotion/models/concerns/segmentable'
+  autoload :Datasetable, 'labimotion/models/concerns/datasetable'
+  autoload :AttachmentConverter, 'labimotion/models/concerns/attachment_converter.rb'
+
+
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: labimotion
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+platform: ruby
+authors:
+- Chia-Lin Lin
+- Pei-Chi Huang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+description: 
+email:
+- chia-lin.lin@kit.edu
+- pei-chi.huang@kit.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/labimotion.rb
+- lib/labimotion/api.rb
+- lib/labimotion/apis/converter_api.rb
+- lib/labimotion/apis/generic_dataset_api.rb
+- lib/labimotion/apis/generic_element_api.rb
+- lib/labimotion/apis/labimotion_hub_api.rb
+- lib/labimotion/apis/segment_api.rb
+- lib/labimotion/entities/application_entity.rb
+- lib/labimotion/entities/dataset_entity.rb
+- lib/labimotion/entities/dataset_klass_entity.rb
+- lib/labimotion/entities/element_entity.rb
+- lib/labimotion/entities/element_klass_entity.rb
+- lib/labimotion/entities/element_revision_entity.rb
+- lib/labimotion/entities/eln_element_entity.rb
+- lib/labimotion/entities/generic_entity.rb
+- lib/labimotion/entities/generic_klass_entity.rb
+- lib/labimotion/entities/generic_public_entity.rb
+- lib/labimotion/entities/klass_revision_entity.rb
+- lib/labimotion/entities/segment_entity.rb
+- lib/labimotion/entities/segment_klass_entity.rb
+- lib/labimotion/entities/segment_revision_entity.rb
+- lib/labimotion/helpers/converter_helpers.rb
+- lib/labimotion/helpers/dataset_helpers.rb
+- lib/labimotion/helpers/element_helpers.rb
+- lib/labimotion/helpers/generic_helpers.rb
+- lib/labimotion/helpers/repository_helpers.rb
+- lib/labimotion/helpers/sample_association_helpers.rb
+- lib/labimotion/helpers/search_helpers.rb
+- lib/labimotion/helpers/segment_helpers.rb
+- lib/labimotion/libs/converter.rb
+- lib/labimotion/libs/export_dataset.rb
+- lib/labimotion/libs/nmr_mapper.rb
+- lib/labimotion/libs/nmr_mapper_repo.rb
+- lib/labimotion/libs/template_hub.rb
+- lib/labimotion/models/collections_element.rb
+- lib/labimotion/models/concerns/attachment_converter.rb
+- lib/labimotion/models/concerns/datasetable.rb
+- lib/labimotion/models/concerns/generic_klass_revisions.rb
+- lib/labimotion/models/concerns/generic_revisions.rb
+- lib/labimotion/models/concerns/segmentable.rb
+- lib/labimotion/models/dataset.rb
+- lib/labimotion/models/dataset_klass.rb
+- lib/labimotion/models/dataset_klasses_revision.rb
+- lib/labimotion/models/datasets_revision.rb
+- lib/labimotion/models/element.rb
+- lib/labimotion/models/element_klass.rb
+- lib/labimotion/models/element_klasses_revision.rb
+- lib/labimotion/models/elements_element.rb
+- lib/labimotion/models/elements_revision.rb
+- lib/labimotion/models/elements_sample.rb
+- lib/labimotion/models/segment.rb
+- lib/labimotion/models/segment_klass.rb
+- lib/labimotion/models/segment_klasses_revision.rb
+- lib/labimotion/models/segments_revision.rb
+- lib/labimotion/utils/con_state.rb
+- lib/labimotion/utils/export.rb
+- lib/labimotion/utils/import.rb
+- lib/labimotion/utils/search.rb
+- lib/labimotion/utils/serializer.rb
+- lib/labimotion/version.rb
+homepage: https://github.com/phuang26/labimotion
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key: 
+specification_version: 4
+summary: Chemotion LabIMotion
+test_files: []