labimotion 1.5.0.rc9 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34535582f9432712614a74a72a54c4793037627d1b02c1a895233e7bb5fb2b85
-  data.tar.gz: 7e3e49f67bbb0bdde267f20a9bb214b53906b5154cad98e3985fb2901e9b7489
+  metadata.gz: 8c1fa1527f921643836476d930d66fedc973e06e2a6300d9e100e2852fc96168
+  data.tar.gz: 4ccc2fe165c170aa98fba5db9d63c576ed997e9650e54da439b1b295da65c816
 SHA512:
-  metadata.gz: 31ac83a6073918c38bfd36dfa8222706282d92ec90c9f4006740c72ef43aa25f5eeead581f72976927ca0ba30028d7c79bbdbb3369137b3cfaaa8980116b526c
-  data.tar.gz: 4fc728cf883e6d9a3f4fcf54193ab823993e424c2bf6d53fa4d924cfb3efec4b5dfc65ab7a122e19b9ac16e7057f392e93bed88e0f302046f77533d498f89e7c
+  metadata.gz: 39915628df304676e86ad4e601d6776e994eb5007cc2f857c48b64498c24dba596d3ae1a46136b1d9c909dc3620724c10f0605682ba34224430c5405324d9076
+  data.tar.gz: fae1a472384cd8ba2c7e93c647399add301ed35e4404038382f451c6b2f2c7644331004c67cba91e76872e844b334fb8041e4a1dbf682dc6644010d9fd7630fe

data/lib/labimotion/apis/standard_api.rb

@@ -13,8 +13,7 @@ module Labimotion
           use :create_std_layer_params
         end
         post do
-          # authenticate_admin!('elements')
-          # create_element_klass(current_user, params)
+          authenticate_admin!('standard_layers')
           create_std_layer(current_user, params)
           status 201
         rescue ActiveRecord::RecordInvalid => e

data/lib/labimotion/apis/standard_layer_api.rb

@@ -7,14 +7,13 @@ module Labimotion
   class StandardLayerAPI < Grape::API
     include Grape::Kaminari
     helpers Labimotion::ParamHelpers
+    helpers Labimotion::GenericHelpers
 
     resource :layers do
       namespace :get_all_layers do
         desc 'get all standard layers for designer'
         get do
           list = Labimotion::StdLayer.all.sort_by { |e| e.name }
-          # present list, with: Labimotion::StdLayer, root: 'klass'
-          # data = Labimotion::StdLayer.represent(col_tree, serializable: true)
           return { mc: 'ss00', data: list }
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)
@@ -24,17 +23,9 @@ module Labimotion
 
       namespace :get_standard_layer do
         desc 'get standard layer by id'
-        # params do
-        #   requires :id, type: Integer, desc: 'Layer id'
-        # end
         route_param :id do
-          before do
-          #   @element_policy = ElementPolicy.new(current_user, Labimotion::Element.find(params[:id]))
-          #   error!('401 Unauthorized', 401) unless current_user.matrix_check_by_name('genericElement') && @element_policy.read?
-          # rescue ActiveRecord::RecordNotFound
-          #   error!('404 Not Found', 404)
-          end
           get do
+            authenticate_admin!('standard_layers')
             entity = Labimotion::StdLayer.find(params[:id])
             return { mc: 'ss00', data: entity }
           rescue StandardError => e
@@ -50,13 +41,9 @@ module Labimotion
           use :std_layer_save
         end
         before do
+          authenticate_admin!('standard_layers')
           cur_layer = Labimotion::StdLayer.find_by(name: params[:key])
           error!('Error! duplicate name', 409) if cur_layer.present?
-          # @element_policy = ElementPolicy.new(current_user, Labimotion::Element.find(params[:id]))
-          # error!('401 Unauthorized', 401) unless current_user.matrix_check_by_name('genericElement') && @element_policy.read?
-        # rescue ActiveRecord::RecordNotFound
-        #   Labimotion.log_exception(e, current_user)
-        #   error!('404 Not Found', 404)
         end
         post do
           attributes = {
@@ -83,7 +70,7 @@ module Labimotion
         end
         route_param :id do
           before do
-            # error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, StdLayer.find(params[:id])).destroy?
+            authenticate_admin!('standard_layers')
           end
           delete do
             entity = Labimotion::StdLayer.find(params[:id])

data/lib/labimotion/apis/vocabulary_api.rb

@@ -7,6 +7,7 @@ module Labimotion
   class VocabularyAPI < Grape::API
     include Grape::Kaminari
     helpers Labimotion::ParamHelpers
+    helpers Labimotion::GenericHelpers
 
     resource :vocab do
       namespace :save_vocabulary do
@@ -15,7 +16,7 @@ module Labimotion
           use :vocab_save
         end
         before do
-          # error!('Error! duplicate record', 409) if ???.present?
+          authenticate_admin!('vocabularies')
         rescue ActiveRecord::RecordNotFound
           error!('404 Not Found', 404)
         end
@@ -30,7 +31,7 @@ module Labimotion
             source_id: params[:source_id],
             layer_id: params[:layer_id],
             field_id: params[:name],
-            identifier: params[:source_id],
+            identifier: SecureRandom.uuid,
             created_by: current_user.id,
             properties: declared(params, include_missing: false),
           }
@@ -46,17 +47,8 @@ module Labimotion
       namespace :get_all_vocabularies do
         desc 'get all standard layers for designer'
         get do
-          # merged_data = []
-          # Dir.glob(Rails.public_path.join('generic', 'vocabularies', '*.json')).each do |file_path|
-          #   file_content = File.read(file_path)
-          #   json_data = JSON.parse(file_content)
-          #   merged_data.concat(json_data)
-          # end
-
-          # list = Labimotion::Vocabulary.all.sort_by { |e| e.name }
-          # present list, with: Labimotion::StdLayer, root: 'klass'
+          authenticate_admin!('vocabularies')
           combined_data = Labimotion::VocabularyHandler.load_all_vocabularies
-          # combined_data = Labimotion::VocabularyEntity.represent(vocabularies, serializable: true)
           return { mc: 'ss00', data: combined_data }
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)
@@ -67,15 +59,9 @@ module Labimotion
       namespace :field_klasses do
         desc 'get all field klasses for admin function'
         get do
-          # Dir.glob(Rails.public_path.join('generic', 'vocabularies', '*.json')).each do |file_path|
-          #   file_content = File.read(file_path)
-          #   json_data = JSON.parse(file_content)
-          #   merged_data.concat(json_data)
-          # end
+          authenticate_admin!('vocabularies')
           vocabularies = Labimotion::VocabularyHandler.load_app_vocabularies
           merged_data = Labimotion::FieldKlassEntity.represent(vocabularies, serializable: true)
-          # list = Labimotion::Vocabulary.all.sort_by { |e| e.name }
-          # present list, with: Labimotion::VocabularyEntity, root: 'klass'
           merged_data
         rescue StandardError => e
           Labimotion.log_exception(e, current_user)
@@ -90,7 +76,7 @@ module Labimotion
         end
         route_param :id do
           before do
-            # error!('401 Unauthorized', 401) unless ElementPolicy.new(current_user, Vocabulary.find(params[:id])).destroy?
+            authenticate_admin!('vocabularies')
           end
           delete do
             entity = Labimotion::Vocabulary.find(params[:id])

data/lib/labimotion/constants.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Labimotion
+  module Constants
+    module DateTime
+      DATE_FORMAT = '%Y-%m-%d'
+      DATETIME_FORMAT = '%Y-%m-%d %H:%M:%S %Z'
+      TIME_FORMAT = '%H:%M:%S %Z'
+      TIME_ZONE = 'UTC'
+    end
+
+    module File
+      ENCODING = 'UTF-8'
+    end
+
+    module CHMO
+      CV = 'Cyclic Voltammetry'
+    end
+
+    module Mapper
+      NMR_CONFIG = ::File.join(__dir__, 'libs', 'data', 'mapper', 'Source.json').freeze
+      WIKI_CONFIG = ::File.join(__dir__, 'libs', 'data', 'mapper', 'Chemwiki.json').freeze
+    end
+  end
+end

data/lib/labimotion/entities/dataset_entity.rb

@@ -12,6 +12,5 @@ module Labimotion
     def klass_label
       object&.dataset_klass&.label
     end
-
   end
 end

data/lib/labimotion/entities/element_entity.rb

@@ -20,6 +20,7 @@ module Labimotion
       expose! :thumb_svg
       expose! :type
       expose! :uuid
+      expose! :user_labels
     end
 
     with_options(anonymize_below: 10) do

data/lib/labimotion/entities/properties_entity.rb

@@ -12,7 +12,7 @@ module Labimotion
     private
 
     def process_layers
-      (object&.properties.is_a?(Hash) && object.properties[Labimotion::Prop::LAYERS]&.keys || []).each do |key|
+      (object&.properties.is_a?(Hash) && (object.properties[Labimotion::Prop::LAYERS]&.keys || [])).each do |key|
         yield(key, object.properties[Labimotion::Prop::LAYERS][key])
       end
     end
@@ -21,11 +21,12 @@ module Labimotion
       process_sample_and_molecule_fields(key, layer)
       process_reaction_fields(key, layer)
       process_table_fields(key, layer)
-      process_voc_fields(key, layer)
+      # process_voc_fields(key, layer)
     end
 
     def process_sample_and_molecule_fields(key, layer)
-      select_fields(layer, [Labimotion::FieldType::DRAG_SAMPLE, Labimotion::FieldType::DRAG_MOLECULE]).each do |field, idx|
+      select_fields(layer,
+                    [Labimotion::FieldType::DRAG_SAMPLE, Labimotion::FieldType::DRAG_MOLECULE]).each do |field, idx|
         update_sample_or_molecule_field(key, field, idx)
       end
     end
@@ -52,7 +53,7 @@ module Labimotion
       fields = layer[Labimotion::Prop::FIELDS]
       fields = fields.select { |f| types.include?(f['type']) } if types
       fields = fields.select { |f| f['is_voc'] == true } if is_voc
-      fields.map { |f| [f, fields.index(f)] }
+      fields.map { |f| [f, layer[Labimotion::Prop::FIELDS].index(f)] }
     end
 
     def update_sample_or_molecule_field(key, field, idx)
@@ -60,13 +61,20 @@ module Labimotion
       return unless sid.present?
 
       el = field['type'] == Labimotion::FieldType::DRAG_SAMPLE ? Sample.find_by(id: sid) : Molecule.find_by(id: sid)
-      return unless el.present? && object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value').present?
+      return unless el.present? && object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx,
+                                                         'value').present?
 
+      label = field['type'] == Labimotion::FieldType::DRAG_SAMPLE ? el&.short_label : el.iupac_name
       update_field_value(key, idx, {
-        'el_label' => el.short_label,
-        'el_tip' => el.short_label,
-        'el_svg' => field['type'] == Labimotion::FieldType::DRAG_SAMPLE ? el.get_svg_path : File.join('/images', 'molecules', el&.molecule_svg_file || 'nosvg')
-      })
+                           'el_label' => label,
+                           'el_tip' => label,
+                           'el_svg' => if field['type'] == Labimotion::FieldType::DRAG_SAMPLE
+                                         el&.get_svg_path
+                                       else
+                                         File.join('/images',
+                                                   'molecules', el&.molecule_svg_file || 'nosvg')
+                                       end
+                         })
     end
 
     def update_reaction_field(key, field, idx)
@@ -79,28 +87,38 @@ module Labimotion
         return
       end
 
-      return unless object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx, 'value').present?
+      return unless object.properties.dig(Labimotion::Prop::LAYERS, key, Labimotion::Prop::FIELDS, idx,
+                                          'value').present?
 
       update_field_value(key, idx, {
-        'el_label' => el.short_label,
-        'el_tip' => el.short_label,
-        'el_svg' => el.reaction_svg_file
-      })
+                           'el_label' => el.short_label,
+                           'el_tip' => el.short_label,
+                           'el_svg' => el.reaction_svg_file
+                         })
     end
 
     def update_table_field(key, field, idx)
       return unless field['sub_values'].present? && field[Labimotion::Prop::SUBFIELDS].present?
 
-      field_table_molecules = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_MOLECULE }
-      object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] = set_table(field, field_table_molecules, Labimotion::Prop::MOLECULE) if field_table_molecules.present?
+      field_table_molecules = field[Labimotion::Prop::SUBFIELDS].select do |ss|
+        ss['type'] == Labimotion::FieldType::DRAG_MOLECULE
+      end
+      if field_table_molecules.present?
+        object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] =
+          set_table(field, field_table_molecules, Labimotion::Prop::MOLECULE)
+      end
+
+      field_table_samples = field[Labimotion::Prop::SUBFIELDS].select do |ss|
+        ss['type'] == Labimotion::FieldType::DRAG_SAMPLE
+      end
+      return unless field_table_samples.present?
 
-      field_table_samples = field[Labimotion::Prop::SUBFIELDS].select { |ss| ss['type'] == Labimotion::FieldType::DRAG_SAMPLE }
-      object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] = set_table(field, field_table_samples, Labimotion::Prop::SAMPLE) if field_table_samples.present?
+      object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx] =
+        set_table(field, field_table_samples, Labimotion::Prop::SAMPLE)
     end
 
     def update_voc_field(key, field, idx)
       root_element = get_root_element
-
       case field['source']
       when Labimotion::Prop::ELEMENT
         update_element_voc_field(key, field, idx, root_element)
@@ -123,9 +141,9 @@ module Labimotion
     end
 
     def update_element_voc_field(key, field, idx, root_element)
-      if field['identifier'] == 'element.name'
-        update_field_value(key, idx, root_element&.name)
-      end
+      return unless field['identifier'] == 'element.name'
+
+      update_field_value(key, idx, root_element&.name)
     end
 
     def update_segment_voc_field(key, field, idx, root_element)
@@ -133,21 +151,28 @@ module Labimotion
       return if segs.empty? || field['layer_id'].blank? || field['field_id'].blank?
 
       seg = segs&.first
-      seg_fields = seg.properties.dig(Labimotion::Prop::LAYERS, field['layer_id'], Labimotion::Prop::FIELDS).select { |ff| ff['field'] == field['field_id'] }
+      seg_fields = seg.properties.dig(Labimotion::Prop::LAYERS, field['layer_id'],
+                                      Labimotion::Prop::FIELDS).select do |ff|
+        ff['field'] == field['field_id']
+      end
       seg_field = seg_fields&.first
       update_field_value(key, idx, seg_field['value'])
     end
 
     def update_dataset_voc_field(key, field, idx, root_element)
-      dk = DatasetKlass.find_by(identifier: field["source_id"])
-      dk["ols_term_id"]
-      anas = root_element.analyses.select { |ana| ana.extended_metadata["kind"].split("|")&.first&.strip == dk["ols_term_id"] }
+      dk = DatasetKlass.find_by(identifier: field['source_id'])
+      dk['ols_term_id']
+      anas = root_element.analyses.select do |ana|
+        ana.extended_metadata['kind'].split('|')&.first&.strip == dk['ols_term_id']
+      end
       anas.each do |ana|
         ana.children.each do |cds|
           next unless cds.dataset.present?
 
           ds_prop = cds.dataset.properties
-          ds_fields = ds_prop.dig(Labimotion::Prop::LAYERS, field['layer_id'], Labimotion::Prop::FIELDS).select { |ff| ff['field'] == field['field_id'] }
+          ds_fields = ds_prop.dig(Labimotion::Prop::LAYERS, field['layer_id'], Labimotion::Prop::FIELDS).select do |ff|
+            ff['field'] == field['field_id']
+          end
           ds_field = ds_fields&.first
           if object.properties[Labimotion::Prop::LAYERS][key].present? && ds_field['value'].present?
             update_field_value(key, idx, ds_field['value'])
@@ -156,15 +181,38 @@ module Labimotion
       end
     end
 
-    def update_field_value(key, idx, value)
-      object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]['value'] = value
+    def update_field_value(key, idx, value, act = 'merge')
+      field_path = object.properties[Labimotion::Prop::LAYERS][key][Labimotion::Prop::FIELDS][idx]
+      original_value = field_path['value']
+
+      field_path['value'] = merge_values(original_value, value, act)
+    end
+
+    def merge_by_type(original_value, new_value)
+      if original_value.is_a?(Hash)
+        merge_hash_values(original_value, new_value)
+      # elsif original_value.is_a?(Array)
+      #   merge_array_values(original_value, new_value)
+      else
+        new_value
+      end
+    end
+
+    def merge_values(original_value, new_value, act)
+      return new_value if act == 'overwrite'
+      return new_value if original_value.blank?
+      return original_value if new_value.blank?
+
+      merge_by_type(original_value, new_value)
     end
 
     def 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?
+          unless sub_value[col_id].present? && sub_value[col_id]['value'].present? && sub_value[col_id]['value']['el_id'].present?
+            next
+          end
 
           find_obj = obj.constantize.find_by(id: sub_value[col_id]['value']['el_id'])
           next if find_obj.blank?
@@ -182,23 +230,35 @@ module Labimotion
 
     def update_molecule_sub_value(sub_value, col_id, find_obj)
       sub_value[col_id]['value'].merge!({
-        'el_svg' => File.join('/images', 'molecules', find_obj.molecule_svg_file),
-        'el_inchikey' => find_obj.inchikey,
-        'el_smiles' => find_obj.cano_smiles,
-        'el_iupac' => find_obj.iupac_name,
-        'el_molecular_weight' => find_obj.molecular_weight
-      })
+                                          'el_svg' => File.join('/images', 'molecules', find_obj.molecule_svg_file),
+                                          'el_inchikey' => find_obj.inchikey,
+                                          'el_smiles' => find_obj.cano_smiles,
+                                          'el_iupac' => find_obj.iupac_name,
+                                          'el_molecular_weight' => find_obj.molecular_weight
+                                        })
     end
 
     def update_sample_sub_value(sub_value, col_id, find_obj)
       sub_value[col_id]['value'].merge!({
-        'el_svg' => find_obj.get_svg_path,
-        'el_label' => find_obj.short_label,
-        'el_short_label' => find_obj.short_label,
-        'el_name' => find_obj.name,
-        'el_external_label' => find_obj.external_label,
-        'el_molecular_weight' => find_obj.decoupled ? find_obj.molecular_mass : find_obj.molecule.molecular_weight
-      })
+                                          'el_svg' => find_obj.get_svg_path,
+                                          'el_label' => find_obj.short_label,
+                                          'el_short_label' => find_obj.short_label,
+                                          'el_name' => find_obj.name,
+                                          'el_external_label' => find_obj.external_label,
+                                          'el_molecular_weight' => find_obj.decoupled ? find_obj.molecular_mass : find_obj.molecule.molecular_weight
+                                        })
+    end
+
+    def merge_hash_values(original, new_value)
+      return original unless new_value.is_a?(Hash)
+
+      original.merge(new_value)
+    end
+
+    def merge_array_values(original, new_value)
+      return original unless new_value.respond_to?(:to_a)
+
+      (original + new_value.to_a).uniq
     end
   end
-end
+end

data/lib/labimotion/entities/segment_entity.rb

@@ -9,7 +9,5 @@ module Labimotion
     def klass_label
       object.segment_klass.label
     end
-
-
   end
 end

data/lib/labimotion/entities/vocabulary_entity.rb

@@ -6,24 +6,15 @@ module Labimotion
   class VocabularyEntity < ApplicationEntity
     expose :id, :identifier, :name, :label, :field_type, :opid, :term_id,
            :field_id, :properties, :source, :source_id, :layer_id
-    # expose :source do |obj|
-    #   (obj[:properties] && obj[:properties]['voc'] && obj[:properties]['voc']['source']) || ''
-    # end
-    # expose :source_id do |obj|
-    #   (obj[:properties] && obj[:properties]['voc'] && obj[:properties]['voc']['source_id']) || ''
-    # end
-    # expose :layer_id do |obj|
-    #   (obj[:properties] && obj[:properties]['voc'] && obj[:properties]['voc']['layer_id']) || ''
-    # end
-
     expose :voc do |obj|
       voc = (obj[:properties] && obj[:properties]['voc']) || {}
 
       case voc['source']
       when Labimotion::Prop::ELEMENT
-        if voc['identifier'] == 'element.name'
+        voc['source_name'] = ElementKlass.find_by(identifier: voc['source_id'])&.label
+        # if voc['identifier'] == 'element.name'
           # voc['source_name'] = ElementKlass.find_by(identifier: voc['source_id'])&.name
-        end
+        # end
       when Labimotion::Prop::SEGMENT
         voc['source_name'] = SegmentKlass.find_by(identifier: voc['source_id'])&.label
       when Labimotion::Prop::DATASET

data/lib/labimotion/helpers/element_helpers.rb

@@ -113,7 +113,6 @@ module Labimotion
       params.delete(:properties)
       update_element_labels(element, params[:user_labels], current_user.id)
       params.delete(:user_labels)
-
       attributes = declared(params.except(:segments), include_missing: false)
       properties['pkg'] = Labimotion::Utils.pkg(properties['pkg'])
       if element.klass_uuid != properties['klass_uuid'] || element.properties != properties || element.name != params[:name]
@@ -124,15 +123,17 @@ module Labimotion
         properties.delete('flow') unless properties['flow'].nil?
         properties.delete('flowObject') unless properties['flowObject'].nil?
         properties.delete('select_options') unless properties['select_options'].nil?
-
         attributes['properties'] = properties
         attributes['properties']['uuid'] = uuid
         attributes['uuid'] = uuid
         attributes['klass_uuid'] = properties['klass_uuid']
-
-        element.update(attributes)
+        element.update_columns(attributes)
       end
       element.save_segments(segments: params[:segments], current_user_id: current_user.id)
+      element.reload
+      element.properties = update_vocabularies(element.properties, current_user, element)
+      ## element.user_for_revision = current_user
+      element.save!
       element
     rescue StandardError => e
       Labimotion.log_exception(e, current_user)

data/lib/labimotion/helpers/generic_helpers.rb

@@ -9,7 +9,12 @@ module Labimotion
     extend Grape::API::Helpers
 
     def authenticate_admin!(type)
-      error!('401 Unauthorized', 401) unless current_user.generic_admin[type]
+      unauthorized = -> { error!('401 Unauthorized', 401) }
+      if %w[standard_layers vocabularies].include?(type)
+        unauthorized.call unless current_user.generic_admin.values_at('elements', 'segments', 'datasets').any?
+      else
+        unauthorized.call unless current_user.generic_admin[type]
+      end
     end
 
     def fetch_klass(name, id)

data/lib/labimotion/helpers/param_helpers.rb

@@ -134,21 +134,5 @@ module Labimotion
       optional :select_options, type: Hash, desc: 'selections'
       optional :option_layers, type: String, desc: 'option'
     end
-
-    # params :vocabulary_save do
-    #   requires :type, type: String, desc: 'type'
-    #   requires :field, type: String, desc: 'field'
-    #   optional :default, type: String, desc: 'default'
-    #   optional :description, type: String, desc: 'description'
-    #   optional :label, type: String, desc: 'label'
-    #   optional :position, type: Integer, desc: 'position'
-    #   optional :ontology, type: Hash, desc: 'ontology'
-    #   optional :required, type: Boolean, desc: 'is required?'
-    #   optional :sub_fields, type: Array, desc: 'sub_fields'
-    #   optional :text_sub_fields, type: Array, desc: 'text_sub_fields'
-    #   optional :source_type, type: String, desc: 'source type'
-    #   optional :source_id, type: String, desc: 'source id'
-    #   optional :layer_id, type: String, desc: 'layer id'
-    # end
   end
 end

data/lib/labimotion/helpers/segment_helpers.rb

@@ -72,7 +72,7 @@ module Labimotion
       # el_attributes['properties_template'] = response['element_klass']['properties_release']
       # Labimotion::ElementKlass.create!(el_attributes)
       attributes['element_klass_id'] = element_klass.id
-      segment_klass = Labimotion::SegmentKlass.find_by(identifier: attributes['identifier'])
+      segment_klass = Labimotion::SegmentKlass.find_by(identifier: attributes['identifier']) if attributes['identifier'].present?
       if segment_klass.present?
         if segment_klass['uuid'] == attributes['uuid'] && segment_klass['version'] == attributes['version']
           return { status: 'success', message: "This segment: #{attributes['label']} has the latest version!" }

data/lib/labimotion/libs/converter.rb

@@ -123,7 +123,6 @@ module Labimotion
         tmp_file.write(response.parsed_response)
         tmp_file.rewind
 
-        # name = response&.headers && response&.headers['content-disposition']&.split('=')&.last
         filename = oat.filename
         name = "#{File.basename(filename, '.*')}.zip"
         att = Attachment.new(