labimotion 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2d2c94d9d6147cab5fd823c611f65c6b41f5140bd018424aae86ca1bd697e1b0
+  data.tar.gz: e5ac11f1be750a698f7285776fc62a1850876b4fa5b53814460f9325d90a832a
+SHA512:
+  metadata.gz: 1430bdaa9a7721c6d5c09b35abde14ee6d2946a7f394fb65a12b9456b026c6734e027c1c36c24195cd36ec4e5701c7f4bba778f4d2fa31f4e6984e491f05eecb
+  data.tar.gz: 5518460a7151dce59e3c20e6e8ca0422a3d443b8aff7c95fecf63d915aa0a6c2e1555b221548bc58ef7194798c48cb4252c3f89454798d27366d9c4a844b1348

data/lib/labimotion/api.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+## This is the first version of the dataset class
+module Labimotion
+  ## This is the first version of the dataset class
+  class Api
+    def initialize
+      # Initialization code
+    end
+
+    def gget_data
+      'Hello, worlddddddddddddddddddddd!'
+    end
+
+    def self.hello
+      'Hellooooooooooooooooooooo!'
+    end
+  end
+end

data/lib/labimotion/apis/converter_api.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Labimotion
+  class ConverterAPI < Grape::API
+    helpers do
+    end
+    resource :converter do
+      resource :profiles do
+        before do
+          @conf = Rails.configuration.try(:converter).try(:url)
+          @profile = Rails.configuration.try(:converter).try(:profile)
+          error!(406) unless @conf && @profile
+        end
+        desc 'fetch profiles'
+        get do
+          profiles = Labimotion::Converter.fetch_profiles
+          { profiles: profiles, client: @profile }
+        end
+        desc 'create profile'
+        post do
+          Labimotion::Converter.create_profile(params)
+        end
+        desc 'update profile'
+        route_param :id do
+          put do
+            Labimotion::Converter.update_profile(params)
+          end
+        end
+        desc 'delete profile'
+        route_param :id do
+          delete do
+            id = params[:id]
+            Labimotion::Converter.delete_profile(id)
+          end
+        end
+      end
+
+      resource :options do
+        before do
+          error!(401) unless current_user.profile&.data['converter_admin'] == true
+          @conf = Rails.configuration.try(:converter).try(:url)
+          @profile = Rails.configuration.try(:converter).try(:profile)
+          error!(406) unless @conf && @profile
+        end
+        desc 'fetch options'
+        get do
+          options = Labimotion::Converter.fetch_options
+          { options: options, client: @profile }
+        end
+      end
+
+      resource :tables do
+        before do
+          error!(401) unless current_user.profile&.data['converter_admin'] == true
+          @conf = Rails.configuration.try(:converter).try(:url)
+          @profile = Rails.configuration.try(:converter).try(:profile)
+          error!(406) unless @conf && @profile
+        end
+        desc 'create tables'
+        post do
+          res = Labimotion::Converter.create_tables(params[:file][0]['tempfile']) unless params[:file].empty?
+          res['metadata']['file_name'] = params[:file][0]['filename']
+          res
+        end
+      end
+    end
+  end
+end

data/lib/labimotion/apis/generic_dataset_api.rb

@@ -0,0 +1,50 @@
+module Labimotion
+  ## Generic Dataset API
+  class GenericDatasetAPI < Grape::API
+    include Grape::Kaminari
+    helpers Labimotion::GenericHelpers
+    helpers Labimotion::DatasetHelpers
+
+    resource :generic_dataset do
+      namespace :klasses do
+        desc 'get dataset klasses'
+        get do
+          list = klass_list(true)
+          present list.sort_by(&:place), with: Labimotion::DatasetKlassEntity, root: 'klass'
+        end
+      end
+
+      namespace :list_dataset_klass do
+        desc 'list Generic Dataset Klass'
+        params do
+          optional :is_active, type: Boolean, desc: 'Active or Inactive Dataset'
+        end
+        get do
+          list = klass_list(params[:is_active])
+          present list, with: Labimotion::DatasetKlassEntity, root: 'klass'
+        end
+      end
+
+      namespace :fetch_repo do
+        desc 'fetch Generic Dataset Klass from Chemotion Repository'
+        get do
+          fetch_repo('DatasetKlass')
+        end
+      end
+
+      namespace :create_repo_klass do
+        desc 'create Generic Dataset Klass'
+        params do
+          requires :identifier, type: String, desc: 'Identifier'
+        end
+        post do
+          create_repo_klass(params, current_user)
+          present DatasetKlass.all, with: Labimotion::DatasetKlassEntity, root: 'klass'
+        rescue => e
+          Labimotion.log_exception(e, current_user)
+          { error: e.message }
+        end
+      end
+    end
+  end
+end

data/lib/labimotion/apis/generic_element_api.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+
+require 'labimotion/version'
+module Labimotion
+  # Generic Element API
+  class GenericElementAPI < Grape::API
+    include Grape::Kaminari
+    helpers ContainerHelpers
+    helpers ParamsHelpers
+    helpers CollectionHelpers
+    helpers Labimotion::SampleAssociationHelpers
+    helpers Labimotion::GenericHelpers
+    helpers Labimotion::ElementHelpers
+
+    resource :generic_elements do
+      namespace :klass do
+        desc 'get klass info'
+        params do
+          requires :name, type: String, desc: 'element klass name'
+        end
+        get do
+          ek = Labimotion::ElementKlass.find_by(name: params[:name])
+          present ek, with: Labimotion::ElementKlassEntity, root: 'klass'
+        end
+      end
+
+      namespace :klasses do
+        desc 'get klasses'
+        params do
+          optional :generic_only, type: Boolean, desc: 'list generic element only'
+        end
+        get do
+          list = klass_list(params[:generic_only])
+          present list, with: Labimotion::ElementKlassEntity, root: 'klass'
+        end
+      end
+
+      namespace :create_element_klass do
+        desc 'create Generic Element Klass'
+        params do
+          requires :name, type: String, desc: 'Element Klass Name'
+          requires :label, type: String, desc: 'Element Klass Label'
+          requires :klass_prefix, type: String, desc: 'Element Klass Short Label Prefix'
+          optional :icon_name, type: String, desc: 'Element Klass Icon Name'
+          optional :desc, type: String, desc: 'Element Klass Desc'
+          optional :properties_template, type: Hash, desc: 'Element Klass properties template'
+        end
+        post do
+          authenticate_admin!('elements')
+          create_element_klass(current_user, params)
+          status 201
+        rescue ActiveRecord::RecordInvalid => e
+          { error: e.message }
+        end
+      end
+
+      namespace :update_element_klass do
+        desc 'update Generic Element Klass'
+        params do
+          requires :id, type: Integer, desc: 'Element Klass ID'
+          optional :label, type: String, desc: 'Element Klass Label'
+          optional :klass_prefix, type: String, desc: 'Element Klass Short Label Prefix'
+          optional :icon_name, type: String, desc: 'Element Klass Icon Name'
+          optional :desc, type: String, desc: 'Element Klass Desc'
+          optional :place, type: String, desc: 'Element Klass Place'
+        end
+        post do
+          authenticate_admin!('elements')
+          update_element_klass(current_user, params)
+        end
+      end
+
+      namespace :klass_revisions do
+        desc 'list Generic Element Revisions'
+        params do
+          requires :id, type: Integer, desc: 'Generic Element Klass Id'
+          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+        end
+        get do
+          list = list_klass_revisions(params)
+          present list, with: Labimotion::KlassRevisionEntity, root: 'revisions'
+        end
+      end
+
+      namespace :element_revisions do
+        desc 'list Generic Element Revisions'
+        params do
+          requires :id, type: Integer, desc: 'Generic Element Id'
+        end
+        get do
+          list = element_revisions(params)
+          present list, with: Labimotion::ElementRevisionEntity, root: 'revisions'
+        end
+      end
+
+      namespace :delete_klass_revision do
+        desc 'delete Klass Revision'
+        params do
+          requires :id, type: Integer, desc: 'Revision ID'
+          requires :klass_id, type: Integer, desc: 'Klass ID'
+          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+        end
+        post do
+          authenticate_admin!(params[:klass].gsub(/(Klass)/, 's').downcase)
+          delete_klass_revision(params)
+          status 201
+        end
+      end
+
+      namespace :delete_revision do
+        desc 'delete Generic Element Revisions'
+        params do
+          requires :id, type: Integer, desc: 'Revision Id'
+          requires :element_id, type: Integer, desc: 'Element ID'
+          requires :klass, type: String, desc: 'Klass', values: %w[Element Segment Dataset]
+        end
+        post do
+          delete_revision(params)
+          status 201
+        end
+      end
+
+      namespace :segment_revisions do
+        desc 'list Generic Element Revisions'
+        params do
+          optional :id, type: Integer, desc: 'Generic Element Id'
+        end
+        get do
+          klass = Labimotion::Segment.find(params[:id])
+          list = klass.segments_revisions unless klass.nil?
+          present list&.sort_by(&:created_at).reverse, with: Labimotion::SegmentRevisionEntity, root: 'revisions'
+        end
+      end
+
+      namespace :upload_generics_files do
+        desc 'upload generic files'
+        params do
+          requires :att_id, type: Integer, desc: 'Element Id'
+          requires :att_type, type: String, desc: 'Element Type'
+        end
+        after_validation do
+          if params[:att_type] == 'Sample' || params[:att_type] == 'Reaction' || params[:att_type] == 'ResearchPlan'
+            el = "#{params[:att_type]}".constantize.find_by(id: params[:att_id])
+          else
+            el = "Labimotion::#{params[:att_type]}".constantize.find_by(id: params[:att_id])
+          end
+          error!('401 Unauthorized', 401) if el.nil?
+
+          policy_updatable = ElementPolicy.new(current_user, el).update?
+          error!('401 Unauthorized', 401) unless policy_updatable
+        end
+        post do
+          upload_generics_files(current_user, params)
+          true
+        end
+      end
+
+      namespace :klasses_all do
+        desc 'get all klasses for admin function'
+        get do
+          list = Labimotion::ElementKlass.all.sort_by { |e| e.place }
+          present list, with: Labimotion::ElementKlassEntity, root: 'klass'
+        end
+      end
+
+      namespace :de_activate_klass do
+        desc 'activate or deactivate Generic Klass'
+        params do
+          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+          requires :id, type: Integer, desc: 'Klass ID'
+          requires :is_active, type: Boolean, desc: 'Active or Inactive Klass'
+        end
+        after_validation do
+          authenticate_admin!(params[:klass].gsub(/(Klass)/, 's').downcase)
+          @klz = fetch_klass(params[:klass], params[:id])
+        end
+        post do
+          deactivate_klass(params)
+        end
+      end
+
+      namespace :delete_klass do
+        desc 'delete Generic Klass'
+        params do
+          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+          requires :id, type: Integer, desc: 'Klass ID'
+        end
+        delete ':id' do
+          delete_klass(params)
+          status 201
+        end
+      end
+
+      namespace :update_template do
+        desc 'update Generic Properties Template'
+        params do
+          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+          requires :id, type: Integer, desc: 'Klass ID'
+          requires :properties_template, type: Hash
+          optional :is_release, type: Boolean, default: false
+        end
+        after_validation do
+          authenticate_admin!(params[:klass].gsub(/(Klass)/, 's').downcase)
+          @klz = fetch_klass(params[:klass], params[:id])
+        end
+        post do
+          update_template(params)
+        end
+      end
+
+      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'
+        optional :filter_created_at, type: Boolean, desc: 'filter by created at or updated at'
+      end
+      paginate per_page: 7, offset: 0, max_per_page: 100
+      get do
+
+        scope = list_serialized_elements(params, current_user)
+
+        reset_pagination_page(scope)
+        if Labimotion::IS_RAILS5 == true
+          generic_elements = paginate(scope).map { |s| ElementListPermissionProxy.new(current_user, s, user_ids).serialized }
+        else
+          generic_elements = paginate(scope).map do |element|
+            Labimotion::ElementEntity.represent(
+              element,
+              displayed_in_list: true,
+              detail_levels: ElementDetailLevelCalculator.new(user: current_user, element: element).detail_levels,
+            )
+          end
+        end
+        { generic_elements: generic_elements }
+      end
+
+      desc 'Return serialized element by id'
+      params do
+        requires :id, type: Integer, desc: 'Element id'
+      end
+      route_param :id do
+        before do
+          error!('401 Unauthorized', 401) unless current_user.matrix_check_by_name('genericElement') && ElementPolicy.new(current_user, Element.find(params[:id])).read?
+        end
+
+        get do
+          element = Labimotion::Element.find(params[:id])
+          if Labimotion::IS_RAILS5 == true
+            {
+              element: ElementPermissionProxy.new(current_user, element, user_ids).serialized,
+              attachments: Entities::AttachmentEntity.represent(element.attachments)
+            }
+          else
+            {
+              element: Labimotion::ElementEntity.represent(
+                element,
+                detail_levels: ElementDetailLevelCalculator.new(user: current_user, element: element).detail_levels,
+              ),
+              attachments: Entities::AttachmentEntity.represent(element.attachments),
+            }
+          end
+        end
+      end
+
+      desc 'Create a element'
+      params do
+        requires :element_klass, type: Hash
+        requires :name, type: String
+        optional :properties, type: Hash
+        optional :properties_release, type: Hash
+        optional :collection_id, type: Integer
+        requires :container, type: Hash
+        optional :segments, type: Array, desc: 'Segments'
+      end
+      post do
+        begin
+          element = create_element(current_user, params)
+          if Labimotion::IS_RAILS5 == true
+            {
+              element: ElementPermissionProxy.new(current_user, element, user_ids).serialized,
+              attachments: Entities::AttachmentEntity.represent(element.attachments)
+            }
+          else
+            present(
+              element,
+              with: Labimotion::ElementEntity,
+              root: :element,
+              detail_levels: ElementDetailLevelCalculator.new(user: current_user, element: element).detail_levels,
+            )
+          end
+        rescue => e
+          Labimotion.log_exception(e, current_user)
+          raise e
+        end
+      end
+
+      desc 'Update element by id'
+      params do
+        requires :id, type: Integer, desc: 'element id'
+        optional :name, type: String
+        requires :properties, type: Hash
+        optional :properties_release, type: Hash
+        requires :container, type: Hash
+        optional :segments, type: Array, desc: 'Segments'
+      end
+      route_param :id do
+        before do
+          error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, Labimotion::Element.find(params[:id])).update?
+        end
+
+        put do
+          begin
+            element = update_element_by_id(current_user, params)
+            if Labimotion::IS_RAILS5 == true
+              {
+                element: ElementPermissionProxy.new(current_user, element, user_ids).serialized,
+                attachments: Entities::AttachmentEntity.represent(element.attachments)
+              }
+            else
+              {
+                element: Labimotion::ElementEntity.represent(
+                  element,
+                  detail_levels: ElementDetailLevelCalculator.new(user: current_user, element: element).detail_levels,
+                ),
+                attachments: Entities::AttachmentEntity.represent(element.attachments),
+              }
+            end
+          rescue => e
+            Labimotion.log_exception(e, current_user)
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/labimotion/apis/labimotion_hub_api.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'open-uri'
+
+# Belong to Chemotion module
+module Labimotion
+  # API for Public data
+  class LabimotionHubAPI < Grape::API
+    include Grape::Kaminari
+
+    namespace :labimotion_hub do
+      namespace :list do
+        desc "get active generic templates"
+        params do
+          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+          optional :with_props, type: Boolean, desc: 'With Properties', default: false
+        end
+        get do
+          list = "Labimotion::#{params[:klass]}".constantize.where(is_active: true).where.not(released_at: nil)
+          list = list.where(is_generic: true) if params[:klass] == 'ElementKlass'
+          entities = Labimotion::GenericPublicEntity.represent(list, displayed: params[:with_props])
+          # entities.length > 1 ? de_encode_json(entities) : []
+        end
+      end
+      namespace :fetch do
+        desc "get active generic templates"
+        params do
+          requires :klass, type: String, desc: 'Klass', values: %w[ElementKlass SegmentKlass DatasetKlass]
+          # requires :fqdn, type: Integer, desc: 'FQDN'
+          requires :identifier, type: String, desc: 'Identifier'
+        end
+        get do
+          entity = "Labimotion::#{params[:klass]}".constantize.find_by(identifier: params[:identifier])
+          "Labimotion::#{params[:klass]}Entity".constantize.represent(entity)
+          # entities.length > 1 ? de_encode_json(entities) : []
+        end
+      end
+
+      namespace :element_klasses_name do
+        desc "get klasses"
+        params do
+          optional :generic_only, type: Boolean, desc: "list generic element only"
+        end
+        get do
+          list = Labimotion::ElementKlass.where(is_active: true) if params[:generic_only].present? && params[:generic_only] == true
+          list = Labimotion::ElementKlass.where(is_active: true) unless params[:generic_only].present? && params[:generic_only] == true
+          list.pluck(:name)
+        end
+      end
+
+    end
+  end
+end

data/lib/labimotion/apis/segment_api.rb

@@ -0,0 +1,144 @@
+module Labimotion
+  class SegmentAPI < Grape::API
+    include Grape::Kaminari
+    helpers Labimotion::GenericHelpers
+    helpers Labimotion::SegmentHelpers
+
+    resource :segments do
+      namespace :klasses do
+        desc "get segment klasses"
+        params do
+          optional :element, type: String, desc: "Klass Element, e.g. Sample, Reaction, Mof,..."
+        end
+        get do
+          list = klass_list(params[:element], true)
+          present list, with: Labimotion::SegmentKlassEntity, root: 'klass'
+        end
+      end
+
+      namespace :list_segment_klass do
+        desc 'list Generic Segment Klass'
+        params do
+          optional :is_active, type: Boolean, desc: 'Active or Inactive Segment'
+        end
+        get do
+          list = klass_list(nil, params[:is_active])
+          present list, with: Labimotion::SegmentKlassEntity, root: 'klass'
+        end
+      end
+
+      namespace :create_segment_klass do
+        desc 'create Generic Segment Klass'
+        params do
+          requires :label, type: String, desc: 'Segment Klass Label'
+          requires :element_klass, type: Integer, desc: 'Element Klass Id'
+          optional :desc, type: String, desc: 'Segment Klass Desc'
+          optional :place, type: String, desc: 'Segment Klass Place', default: '100'
+          optional :properties_template, type: Hash, desc: 'Element Klass properties template'
+        end
+        after_validation do
+          authenticate_admin!('segments')
+          @klass = fetch_klass('ElementKlass', params[:element_klass])
+        end
+        post do
+          create_segment_klass(current_user, params)
+        rescue ActiveRecord::RecordInvalid => e
+          { error: e.message }
+        end
+      end
+
+      namespace :update_segment_klass do
+        desc 'update Generic Segment Klass'
+        params do
+          requires :id, type: Integer, desc: 'Segment Klass ID'
+          optional :label, type: String, desc: 'Segment Klass Label'
+          optional :desc, type: String, desc: 'Segment Klass Desc'
+          optional :place, type: String, desc: 'Segment Klass Place', default: '100'
+          optional :identifier, type: String, desc: 'Segment Identifier'
+        end
+        after_validation do
+          authenticate_admin!('segments')
+        end
+        post do
+          update_segment_klass(current_user, params)
+        rescue => e
+          Labimotion.log_exception(e, current_user)
+          { error: e.message }
+        end
+      end
+
+      namespace :fetch_repo_generic_template do
+        desc 'fetch segment templates from repository'
+        params do
+          requires :identifier, type: String, desc: 'identifier'
+        end
+        post do
+          sk_obj = fetch_repo_generic_template('Segment', params[:identifier])
+          sk_obj = sk_obj.deep_symbolize_keys[:generic_template]
+          return { error: 'No template data found' } unless sk_obj.present?
+
+          ek_obj = Labimotion::ElementKlass.find_by(name: sk_obj.dig(:element_klass, :klass_name))
+          return { error: 'No related element data found' } unless ek_obj.present?
+
+          segment_klass = Labimotion::SegmentKlass.find_or_create_by(
+            identifier: sk_obj.dig(:identifier),
+          )
+          segment_klass.update(sk_obj.slice(
+            :label,
+            :desc,
+            :place,
+            :properties_release,
+            :uuid,
+          ).merge(
+            is_active: true,
+            properties_template: sk_obj.dig(:properties_release), # properties_release,
+            element_klass: ek_obj,
+            created_by: current_user.id,
+            released_at: DateTime.now,
+            sync_time: DateTime.now,
+          ))
+
+          present segment_klass, with: Labimotion::SegmentKlassEntity, root: 'klass'
+        rescue => e
+          Labimotion.log_exception(e, current_user)
+          { error: e.message }
+        end
+      end
+
+      namespace :fetch_repo_generic_template_list do
+        desc 'fetch segment templates from repository'
+        get do
+          fetch_repo_generic_template_list('Segment')
+        rescue => e
+          Labimotion.log_exception(e, current_user)
+          { error: e.message }
+        end
+      end
+
+      namespace :fetch_repo do
+        desc 'fetch Generic Segment Klass from Chemotion Repository'
+        get do
+          fetch_repo('SegmentKlass')
+        rescue => e
+          Labimotion.log_exception(e, current_user)
+          { error: e.message }
+        end
+      end
+
+      namespace :create_repo_klass do
+        desc 'create Generic Segment Klass'
+        params do
+          requires :identifier, type: String, desc: 'Identifier'
+        end
+        post do
+          create_repo_klass(params, current_user)
+          present SegmentKlass.all, with: Labimotion::SegmentKlassEntity, root: 'klass'
+        rescue => e
+          Labimotion.log_exception(e, current_user)
+          ## { error: e.message }
+          raise e
+        end
+      end
+    end
+  end
+end