labimotion 0.1.6

data/lib/labimotion/helpers/search_helpers.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require 'grape'
+# require 'labimotion/models/segment_klass'
+module Labimotion
+  ## ElementHelpers
+  module SearchHelpers
+    extend Grape::API::Helpers
+
+    def serialization_elements(result, page, page_size, element_ids, params)
+      # klasses = Labimotion::ElementKlass.where(is_active: true, is_generic: true)
+      # klasses.each do |klass|
+      #   element_ids_for_klass = Element.where(id: element_ids, element_klass_id: klass.id).pluck(:id)
+      #   paginated_element_ids = Kaminari.paginate_array(element_ids_for_klass).page(page).per(page_size)
+      #   serialized_elements = Element.find(paginated_element_ids).map do |element|
+      #     Labimotion::ElementEntity.represent(element, displayed_in_list: true).serializable_hash
+      #   end
+
+      #   result["#{klass.name}s"] = {
+      #     elements: serialized_elements,
+      #     totalElements: element_ids_for_klass.size,
+      #     page: page,
+      #     pages: pages(element_ids_for_klass.size),
+      #     perPage: page_size,
+      #     ids: element_ids_for_klass,
+      #   }
+      # end
+      # result
+    end
+
+
+    def gl_elements_search(col, params)
+      # element_scope = Element.joins(:collections_elements).where(
+      #   'collections_elements.collection_id = ? and collections_elements.element_type = (?)', collection.id, params[:selection][:genericElName]
+      # )
+      # if params[:selection][:searchName].present?
+      #   element_scope = element_scope.where('name like (?)',
+      #                                       "%#{params[:selection][:searchName]}%")
+      # end
+      # if params[:selection][:searchShowLabel].present?
+      #   element_scope = element_scope.where('short_label like (?)', "%#{params[:selection][:searchShowLabel]}%")
+      # end
+      # if params[:selection][:searchProperties].present?
+      #   params[:selection][:searchProperties] && params[:selection][:searchProperties][:layers] && params[:selection][:searchProperties][:layers].keys.each do |lk|
+      #     layer = params[:selection][:searchProperties][:layers][lk]
+      #     qs = layer[:fields].select { |f| f[:value].present? || f[:type] == 'input-group' }
+      #     qs.each do |f|
+      #       if f[:type] == 'input-group'
+      #         sfs = f[:sub_fields].map { |e| { id: e[:id], value: e[:value] } }
+      #         query = { "#{lk}": { fields: [{ field: f[:field].to_s, sub_fields: sfs }] } } if sfs.length > 0
+      #       elsif f[:type] == 'checkbox' || f[:type] == 'integer' || f[:type] == 'system-defined'
+      #         query = { "#{lk}": { fields: [{ field: f[:field].to_s, value: f[:value] }] } }
+      #       else
+      #         query = { "#{lk}": { fields: [{ field: f[:field].to_s, value: f[:value].to_s }] } }
+      #       end
+      #       element_scope = element_scope.where('properties @> ?', query.to_json)
+      #     end
+      #   end
+      # end
+      # element_scope
+    end
+  end
+end

data/lib/labimotion/helpers/segment_helpers.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+require 'grape'
+require 'labimotion/models/segment_klass'
+module Labimotion
+  ## ElementHelpers
+  module SegmentHelpers
+    extend Grape::API::Helpers
+
+    def klass_list(el_klass, is_active=false)
+      scope = SegmentKlass.all
+      scope = scope.where(is_active: is_active) if is_active.present? && is_active == true
+      scope = scope.joins(:element_klass).where(klass_element: params[:element], is_active: true) if el_klass.present?
+      scope.order('place') || []
+    end
+
+    def create_segment_klass(current_user, params)
+      place = params[:place]
+      begin
+        place = place.to_i if place.present? && place.to_i == place.to_f
+      rescue StandardError
+        place = 100
+      end
+
+      uuid = SecureRandom.uuid
+      template = { uuid: uuid, layers: {}, select_options: {} }
+      attributes = declared(params, include_missing: false)
+      attributes[:properties_template]['uuid'] = uuid if attributes[:properties_template].present?
+      template = (attributes[:properties_template].presence || template)
+      template['eln'] = Chemotion::Application.config.version
+      template['labimotion'] = Labimotion::VERSION
+      template['klass'] = 'SegmentKlass'
+      attributes.merge!(properties_template: template, element_klass: @klass, created_by: current_user.id,
+                        place: place)
+      attributes[:is_active] = false
+      attributes[:uuid] = uuid
+      attributes[:released_at] = DateTime.now
+      attributes[:properties_release] = attributes[:properties_template]
+      klass = Labimotion::SegmentKlass.create!(attributes)
+      klass.reload
+      klass.create_klasses_revision(current_user.id)
+      klass
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def update_segment_klass(current_user, params)
+      segment = fetch_klass('SegmentKlass', params[:id])
+      place = params[:place]
+      begin
+        place = place.to_i if place.present? && place.to_i == place.to_f
+      rescue StandardError
+        place = 100
+      end
+      attributes = declared(params, include_missing: false)
+      attributes.delete(:id)
+      attributes[:place] = place
+      segment&.update!(attributes)
+      segment
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+
+    def create_repo_klass(params, current_user)
+      response = Labimotion::TemplateHub.fetch_identifier('SegmentKlass', params[:identifier])
+byebug
+      attributes = response.slice('label', 'desc', 'uuid', 'identifier', 'released_at') # .except(:id, :is_active, :place, :created_by, :created_at, :updated_at)
+      attributes['properties_template'] = response['properties_release']
+      attributes['place'] = ((Labimotion::SegmentKlass.all.length * 10) || 0) + 10
+      attributes['is_active'] = false
+      attributes['updated_by'] = current_user.id
+      attributes['sync_by'] = current_user.id
+      attributes['sync_time'] = DateTime.now
+
+      element_klass = Labimotion::ElementKlass.find_by(identifier: response['element_klass']['identifier'])
+      element_klass = Labimotion::ElementKlass.find_by(name: response['element_klass']['name']) if element_klass.nil?
+      if element_klass.nil?
+        el_attributes = response['element_klass'].slice('name', 'label', 'desc', 'uuid', 'identifier', 'icon_name', 'klass_prefix', 'is_generic', 'released_at')
+        el_attributes['properties_template'] = response['element_klass']['properties_release']
+        Labimotion::ElementKlass.create!(el_attributes)
+      end
+
+
+      if Labimotion::SegmentKlass.find_by(ols_term_id: attributes['ols_term_id']).present?
+        ds = Labimotion::SegmentKlass.find_by(ols_term_id: attributes['ols_term_id'])
+        ds.update!(attributes)
+      else
+        attributes['created_by'] = current_user.id
+        Labimotion::SegmentKlass.create!(attributes)
+      end
+    rescue => e
+      Labimotion.log_exception(e, current_user)
+      raise e
+    end
+  end
+end

data/lib/labimotion/libs/converter.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+require 'date'
+require 'labimotion/version'
+
+# rubocop: disable Metrics/AbcSize
+# rubocop: disable Metrics/MethodLength
+# rubocop: disable Metrics/ClassLength
+# rubocop: disable Metrics/CyclomaticComplexity
+
+module Labimotion
+  class Converter
+
+    def self.logger
+      @@converter_logger ||= Logger.new(Rails.root.join('log/converter.log')) # rubocop:disable Style/ClassVars
+    end
+
+    def self.uri(api_name)
+      url = Rails.configuration.converter.url
+      "#{url}#{api_name}"
+    end
+
+    def self.timeout
+      Rails.configuration.try(:converter).try(:timeout) || 30
+    end
+
+    def self.extname
+      '.jdx'
+    end
+
+    def self.client_id
+      Rails.configuration.converter.profile || ''
+    end
+
+    def self.secret_key
+      Rails.configuration.converter.secret_key || ''
+    end
+
+    def self.auth
+      { username: client_id, password: secret_key }
+    end
+
+    def self.date_time
+      DateTime.now.strftime('%Q')
+    end
+
+    def self.signature(jbody)
+      md5 = Digest::MD5.new
+      md5.update jbody
+      mdhex = md5.hexdigest
+      mdall = mdhex << secret_key
+      @signature = Digest::SHA1.hexdigest mdall
+    end
+
+    def self.header(opt = {})
+      opt || {}
+    end
+
+    def self.vor_conv(id)
+      conf = Rails.configuration.try(:converter).try(:url)
+      oa = Attachment.find(id)
+      folder = Rails.root.join('tmp/uploads/converter')
+      FileUtils.mkdir_p(folder)
+      return nil if conf.nil? || oa.nil?
+
+      { a: oa, f: folder }
+    end
+
+    def self.collect_metadata(zip_file) # rubocop: disable Metrics/PerceivedComplexity
+      dsr = []
+      ols = nil
+      zip_file.each do |entry|
+        next unless entry.name == 'metadata/converter.json'
+
+        metadata = entry.get_input_stream.read.force_encoding('UTF-8')
+        jdata = JSON.parse(metadata)
+
+        ols = jdata['ols']
+        matches = jdata['matches']
+        matches&.each do |match|
+          idf = match['identifier']
+          idr = match['result']
+          if idf&.class == Hash && idr&.class == Hash && !idf['outputLayer'].nil? && !idf['outputKey'].nil? && !idr['value'].nil? # rubocop:disable Layout/LineLength
+            dsr.push(layer: idf['outputLayer'], field: idf['outputKey'], value: idr['value'])
+          end
+        end
+      end
+      { d: dsr, o: ols }
+    end
+
+    def self.handle_response(oat, response) # rubocop: disable Metrics/PerceivedComplexity
+      dsr = []
+      ols = nil
+
+      begin
+        tmp_file = Tempfile.new(encoding: 'ascii-8bit')
+        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" if name.nil?
+
+        att = Attachment.new(
+          filename: name,
+          file_path: tmp_file.path,
+          ## content_type: file[:type],
+          attachable_id: oat.attachable_id,
+          attachable_type: 'Container',
+          con_state: Labimotion::ConState::CONVERTED,
+          created_by: oat.created_by,
+          created_for: oat.created_for,
+        )
+        # att.attachment_attacher.attach(tmp_file)
+        if att.valid? && Labimotion::IS_RAILS5 == false
+          att.attachment_attacher.create_derivatives
+          att.save!
+        end
+        if att.valid? && Labimotion::IS_RAILS5 == true
+          primary_store = Rails.configuration.storage.primary_store
+          att.update!(storage: primary_store)
+        end
+
+        Zip::File.open(tmp_file.path) do |zip_file|
+          res = Labimotion::Converter.collect_metadata(zip_file) if name.split('.')&.last == 'zip'
+          ols = res[:o] unless res&.dig(:o).nil?
+          dsr.push(res[:d]) unless res&.dig(:d).nil?
+        end
+
+        dsr.flatten!
+        if dsr.length.positive? && name.split('.')&.last == 'zip'
+          Labimotion::Converter.ts('write', att.attachable_id, ols: ols, info: dsr)
+        end
+      rescue StandardError => e
+        raise e
+      ensure
+        tmp_file&.close
+      end
+    end
+
+    def self.process(data)
+      return if data[:a]&.attachable_type != 'Container'
+
+      response = nil
+      begin
+        ofile = Rails.root.join(data[:f], data[:a].filename)
+        FileUtils.cp(data[:a].store.path, ofile)
+        File.open(ofile, 'r') do |f|
+          body = { file: f }
+          response = HTTParty.post(
+            uri('conversions'),
+            basic_auth: auth,
+            body: body,
+            timeout: timeout,
+          )
+        end
+        if response.ok?
+          Labimotion::Converter.handle_response(data[:a], response)
+        else
+          Labimotion::Converter.logger.error ["Converter Response Error: id: [#{data[:a]&.id}], filename: [#{data[:a]&.filename}], response: #{response}"].join($INPUT_RECORD_SEPARATOR)
+        end
+        response
+      rescue StandardError => e
+        raise e
+      ensure
+        FileUtils.rm_f(ofile)
+      end
+    end
+
+    def self.jcamp_converter(id)
+      resp = nil
+      begin
+        data = Labimotion::Converter.vor_conv(id)
+        return if data.nil?
+
+        resp = Labimotion::Converter.process(data)
+        resp&.success? ? Labimotion::ConState::PROCESSED : Labimotion::ConState::ERROR
+      rescue StandardError => e
+        Labimotion::ConState::ERROR
+        Labimotion::Converter.logger.error ["jcamp_converter fail: #{id}", e.message, *e.backtrace].join($INPUT_RECORD_SEPARATOR)
+      end
+    end
+
+    def self.generate_ds(att_id, current_user = {})
+      dsr_info = Labimotion::Converter.fetch_dsr(att_id)
+      begin
+        return unless dsr_info && dsr_info[:info]&.length.positive?
+        dataset = Labimotion::Converter.build_ds(att_id, dsr_info[:ols])
+        Labimotion::Converter.update_ds(dataset, dsr_info[:info], current_user)
+      rescue StandardError => e
+        Labimotion::Converter.logger.error ["Att ID: #{att_id}, OLS: #{dsr_info[:ols]}", "DSR: #{dsr_info[:info]}", e.message, *e.backtrace].join($INPUT_RECORD_SEPARATOR)
+      ensure
+        Labimotion::Converter.clean_dsr(att_id)
+      end
+    end
+
+    def self.build_ds(att_id, ols)
+      cds = Container.find_by(id: att_id)
+      dataset = Labimotion::Dataset.find_by(element_type: 'Container', element_id: cds.id)
+      return dataset unless dataset.nil?
+
+      klass = Labimotion::DatasetKlass.find_by(ols_term_id: ols)
+      return if klass.nil?
+
+      uuid = SecureRandom.uuid
+      props = klass.properties_release
+      props['uuid'] = uuid
+      props['eln'] = Chemotion::Application.config.version
+      props['labimotion'] = Labimotion::VERSION
+      props['klass'] = 'Dataset'
+      Labimotion::Dataset.create!(
+        uuid: uuid,
+        dataset_klass_id: klass.id,
+        element_type: 'Container',
+        element_id: cds.id,
+        properties: props,
+        properties_release: klass.properties_release,
+        klass_uuid: klass.uuid
+      )
+    end
+
+    def self.update_ds(dataset, dsr, current_user = nil) # rubocop: disable Metrics/PerceivedComplexity
+      layers = dataset.properties['layers'] || {}
+      new_prop = dataset.properties
+      dsr.each do |ds|
+        layer = layers[ds[:layer]]
+        fields = layer['fields'].select{ |f| f['field'] == ds[:field] }
+        fi = fields&.first
+        idx = layer['fields'].find_index(fi)
+        fi['value'] = ds[:value]
+        fi['device'] = ds[:device] || ds[:value]
+        new_prop['layers'][ds[:layer]]['fields'][idx] = fi
+      end
+      new_prop.dig('layers', 'general', 'fields')&.each_with_index do |fi, idx|
+        if fi['field'] == 'creator' && current_user.present?
+          fi['label'] = fi['label']
+          fi['value'] = current_user.name
+          fi['system'] = current_user.name
+          new_prop['layers']['general']['fields'][idx] = fi
+        end
+      end
+      element = Container.find(dataset.element_id)&.root_element
+      element.present? && element&.class&.name == 'Sample' && new_prop.dig('layers', 'sample_details', 'fields')&.each_with_index do |fi, idx|
+        if fi['field'] == 'id'
+          fi['value'] = element.id
+          fi['system'] = element.id
+          new_prop['layers']['general']['fields'][idx] = fi
+        end
+
+        if fi['field'] == 'label'
+          fi['value'] = element.short_label
+          fi['system'] = element.short_label
+          new_prop['layers']['general']['fields'][idx] = fi
+        end
+      end
+      dataset.properties = new_prop
+      dataset.save!
+    end
+
+    def self.ts(method, identifier, params = nil)
+      Rails.cache.send(method, "#{Labimotion::Converter.new.class.name}#{identifier}", params)
+    end
+
+    def self.fetch_dsr(att_id)
+      Labimotion::Converter.ts('read', att_id)
+    end
+
+    def self.clean_dsr(att_id)
+      Labimotion::Converter.ts('delete', att_id)
+    end
+
+    def self.fetch_options
+      options = { basic_auth: auth, timeout: timeout }
+      response = HTTParty.get(uri('options'), options)
+      response.parsed_response if response.code == 200
+    end
+
+    def self.delete_profile(id)
+      options = { basic_auth: auth, timeout: timeout }
+      response = HTTParty.delete("#{uri('profiles')}/#{id}", options)
+      response.parsed_response if response.code == 200
+    end
+
+    def self.create_profile(data)
+      options = { basic_auth: auth, timeout: timeout, body: data.to_json, headers: { 'Content-Type' => 'application/json' } }
+      response = HTTParty.post(uri('profiles'), options)
+      response.parsed_response if response.code == 201
+    end
+
+    def self.update_profile(data)
+      options = { basic_auth: auth, timeout: timeout, body: data.to_json, headers: { 'Content-Type' => 'application/json' } }
+      response = HTTParty.put("#{uri('profiles')}/#{data[:id]}", options)
+      response.parsed_response if response.code == 200
+    end
+
+    def self.fetch_profiles
+      options = { basic_auth: auth, timeout: timeout }
+      response = HTTParty.get(uri('profiles'), options)
+      response.parsed_response if response.code == 200
+    end
+
+    def self.create_tables(tmpfile)
+      res = {}
+      File.open(tmpfile.path, 'r') do |file|
+        body = { file: file }
+        response = HTTParty.post(
+          uri('tables'),
+          basic_auth: auth,
+          body: body,
+          timeout: timeout,
+        )
+        res = response.parsed_response
+      end
+      res
+    end
+  end
+end
+
+# rubocop: enable Metrics/AbcSize
+# rubocop: enable Metrics/MethodLength
+# rubocop: enable Metrics/ClassLength
+# rubocop: enable Metrics/CyclomaticComplexity

data/lib/labimotion/libs/export_dataset.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+require 'export_table'
+
+module Labimotion
+  ## ExportDataset
+  class ExportDataset
+    DEFAULT_ROW_WIDTH = 100
+    DEFAULT_ROW_HEIGHT = 20
+
+    def initialize(**args)
+      @xfile = Axlsx::Package.new
+      @file_extension = 'xlsx'
+      @xfile.workbook.styles.fonts.first.name = 'Calibri'
+    end
+
+    def res_name(id)
+      element_name = Container.find(id)&.root_element&.short_label
+      ols = ols_name(id)
+      "#{element_name}_#{ols.gsub(' ', '_')}.xlsx"
+    end
+
+    def ols_name(id)
+      ds = Labimotion::Dataset.find_by(element_id: id, element_type: 'Container')
+      return nil if ds.nil?
+
+      name = ds.dataset_klass.label
+
+      match = name.match(/\((.*?)\)/)
+      name = match && match.length > 2 ? match[1] : name
+
+      name = '1H NMR' if ds.dataset_klass.ols_term_id == 'CHMO:0000593'
+      name = '13C NMR' if ds.dataset_klass.ols_term_id == 'CHMO:0000595'
+      name.slice(0, 26)
+    end
+
+    def description(ds, id)
+      wb = @xfile.workbook
+      sheet = @xfile.workbook.add_worksheet(name: 'Description')
+      header_style = sheet.styles.add_style(sz: 12, fg_color: 'FFFFFF', bg_color: '00008B', border: { style: :thick, color: 'FF777777', edges: [:bottom] })
+      sheet.add_row(['File name', res_name(id)])
+      sheet.add_row(['Time', Time.now.strftime("%Y-%m-%d %H:%M:%S %Z")] )
+      sheet.add_row([''])
+      sheet.add_row(['Fields description of sheet:' + ds.dataset_klass.label])
+      sheet.add_row(['Fields', 'Field description'], style: header_style)
+      sheet.add_row(['Layer Label', 'The label of the layer'])
+      sheet.add_row(['Field Label', 'The label of the field'])
+      sheet.add_row(['Value', 'The current value of the field'])
+      sheet.add_row(['Unit', 'The unit of the field'])
+      sheet.add_row(['Name', 'The key of the field, can be used to identify the field'])
+      sheet.add_row(['Type', 'The type of the field'])
+      sheet.add_row(['From device?', '[Yes] if the field is from the device, [No] if the field is manually entered by the user, [SYS] if the field is automatically generated by the system'])
+      sheet.add_row(['Device source', 'The source tag of the device file, available only if the ontology term is 1H NMR or 13C NMR'])
+      sheet.add_row(['Device data', 'The original device data, can not be changed after data uploaded'])
+      sheet.add_row([''])
+      sheet.add_row([''])
+      sheet.add_row([''])
+      sheet.add_row(['', '(This file is automatically generated by the system.)'])
+    end
+
+    def export(id)
+      ds = Labimotion::Dataset.find_by(element_id: id, element_type: 'Container')
+      return if ds.nil?
+
+      description(ds, id)
+
+      wb = @xfile.workbook
+      name = ols_name(id)
+      return if name.nil?
+
+      sheet = @xfile.workbook.add_worksheet(name: name)
+      sheet.add_row([ds.dataset_klass.label])
+      header_style = sheet.styles.add_style(sz: 12, fg_color: 'FFFFFF', bg_color: '00008B', border: { style: :thick, color: 'FF777777', edges: [:bottom] })
+      layer_style = sheet.styles.add_style(b: true, bg_color: 'CEECF5')
+      sheet.add_row(header, style: header_style)
+
+      layers = ds.properties['layers'] || {}
+      layer_keys = layers.keys.sort_by { |key| layers[key]['position'] }
+      layer_keys.each do |key|
+        layer = layers[key]
+        sheet.add_row([layer['label'], ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '], style: layer_style)
+        sorted_fields = layer['fields'].sort_by { |obj| obj['position'] }
+        sorted_fields.each do |field|
+          next if field['type'] == 'dummy'
+
+          type = field['type']
+          from_device = field['device'].present? ? 'Yes' : 'No'
+          from_device = field['system'].present? ? 'SYS' : from_device
+          type = "#{field['type']}-#{field['option_layers']}" if field['type'] == 'select' || field['type'] == 'system-defined'
+
+          show_value = field['value'] =~ /\A\d+,\d+\z/ ? field['value']&.gsub(',', '.') : field['value']
+          sheet.add_row([' ', field['label'], show_value, field['value_system'], field['field'], type, from_device, field['dkey'], field['system'] || field['device']].freeze)
+        end
+        # sheet.column_widths nil, nil, nil, nil, 0, 0, 0, 0, 0
+      end
+    end
+
+    def spectra(id)
+      wb = @xfile.workbook
+      gds = Labimotion::Dataset.find_by(element_id: id, element_type: 'Container')
+      cds = Container.find(id)
+      cds.attachments.where(aasm_state: 'csv').each do |att|
+        name = File.basename(att.filename, '.csv')
+        sheet = @xfile.workbook.add_worksheet(name: name)
+        File.open(att.store.path) do |fi|
+          fi.each_line do |line|
+            sheet.add_row(line.split(','))
+          end
+        end
+      end
+    end
+
+    def header
+      ['Layer Label', 'Field Label', 'Value', 'Unit', 'Name', 'Type', 'from device?', 'Device source', 'Device data'].freeze
+    end
+
+    def read
+      @xfile.to_stream.read
+    end
+
+  end
+end