labimotion 2.0.0.rc3 → 2.0.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d75eb36d68f9212354fef2d83838274d4a4b59a59852c80ce2f0c26f2852c95
-  data.tar.gz: 1cc4625e88286bcd2febeb0b2ded75c3091f416c93db7d505e703ed04e8ce849
+  metadata.gz: aab9882de072c222a6e67a54d30eabe5f81733531e36cf702fcf3383cc526981
+  data.tar.gz: a84933a64d143182e581afd1c69ae8bee6dec8ce462c6eec9fa90b48da64df2a
 SHA512:
-  metadata.gz: c630024f9111ad2c991cf8a442d8958fa4641f1b050a1c9894fab37ad1208537a650065139a13243ba560ad1c77cf77a633a3c74853a7c2857833331b3f03123
-  data.tar.gz: 4cee0102f4d4e88ba2e840eccada4294751de262c4b7a232cda167cca23970550df901343a7b1e6a0f1e5c66b4c803bd4e6b0e126ea708ca94a24579e7285b50
+  metadata.gz: 59430594a0b79bf838688ffd2f3f71e928e582ee9b44f11a3dbf5cdbc0ba30e2d971dc25e2b538027357a06a04d2f61d05dfbc0a151f41e65de580633d238db6
+  data.tar.gz: 895e4a24ab94b5b92a2fbcafdfeb90cc1ee040d75c7fbe8b142de08293b8c503f9551f64865ee3a2980811f8344dabc7159f43992c972c80ff455661c70bfd7d

data/lib/labimotion/constants.rb

@@ -15,6 +15,7 @@ module Labimotion
 
     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/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
@@ -25,7 +25,8 @@ module Labimotion
     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
@@ -60,13 +61,19 @@ 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?
 
       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' => el&.short_label,
+                           'el_tip' => el&.short_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,23 +86,34 @@ 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)
@@ -122,9 +140,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)
@@ -132,21 +150,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'])
@@ -155,15 +180,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?
@@ -181,23 +229,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/libs/data/mapper/Chemwiki.json

@@ -0,0 +1,236 @@
+{
+  "CHMO:0000025": {
+    "index": ["A", "B", "C", "Q1", "Q2", "Q3", "G", "H", "Q4", "Q5", "K", "L", "Q6", "N", "O", "P", "Q7", "R", "S", "T", "U", "V", "W", "X", "Q8", "Q9", "Q10"],
+    "mapper": {
+      "A": {
+        "sources": ["inchikey"]
+      },
+      "B": {
+        "sources": ["molfile"]
+      },
+      "C": {
+        "sources": ["concentration"]
+      },
+      "G": {
+        "sources": ["solvent_volume"]
+      },
+      "H": {
+        "sources": ["elect_inchikey"]
+      },
+      "K": {
+        "sources": ["elect_concentration"]
+      },
+      "L": {
+        "sources": ["reference_internal"]
+      },
+      "N": {
+        "sources": ["scan_rate"]
+      },
+      "O": {
+        "sources": ["scan_number"]
+      },
+      "P": {
+        "sources": ["voltage_limit_one", "voltage_limit_two"],
+        "separator": ","
+      },
+      "R": {
+        "sources": ["atmosphere"]
+      },
+      "S": {
+        "sources": ["temperature"]
+      },
+      "T": {
+        "sources": ["condition"]
+      },
+      "U": {
+        "sources": ["we"]
+      },
+      "V": {
+        "sources": ["we_area"]
+      },
+      "W": {
+        "sources": ["ce"]
+      },
+      "X": {
+        "sources": ["re"]
+      },
+      "Q1": {
+        "sources": ["redox"],
+        "separator": ","
+      },
+      "Q2": {
+        "sources": ["solvent"]
+      },
+      "Q3": {
+        "sources": ["solvent_molfile"]
+      },
+      "Q4": {
+        "sources": ["elect_molfile"]
+      },
+      "Q5": {
+        "sources": ["elect_purity"]
+      },
+      "Q6": {
+        "sources": ["reference_internal_compound_molfile"]
+      },
+      "Q7": {
+        "sources": ["scan_direction"],
+        "separator": ","
+      },
+      "Q8": {
+        "sources": ["details"],
+        "separator": ","
+      },
+      "Q9": {
+        "sources": ["includes"],
+        "separator": ","
+      },
+      "Q10": {
+        "sources": ["base_page"],
+        "separator": ","
+      }
+    },
+    "source": {
+      "concentration": {
+        "title": "Analyte concentration [mM]",
+        "param": "sample_preparation.concentration",
+        "type": "dataset"
+      },
+      "temperature": {
+        "title": "Temperature [°C]",
+        "param": "set.temperature",
+        "type": "dataset"
+      },
+      "condition": {
+        "title": "Condition",
+        "param": "set.conditions",
+        "type": "dataset"
+      },
+      "scan_rate": {
+        "title": "Scan rate [mV/s]",
+        "param": "meas.scan_rate",
+        "type": "dataset"
+      },
+      "atmosphere": {
+        "title": "Gas",
+        "param": "set.atmosphere",
+        "type": "dataset"
+      },
+      "scan_number": {
+        "title": "Scan number",
+        "param": "meas.cycles",
+        "type": "dataset"
+      },
+      "we": {
+        "title": "Working electrode",
+        "param": "electrodes.working",
+        "type": "dataset"
+      },
+      "we_area": {
+        "title": "Working electrode surface area",
+        "param": "electrodes.working_area",
+        "type": "dataset"
+      },
+      "ce": {
+        "title": "Counter electrode",
+        "param": "electrodes.counter",
+        "type": "dataset"
+      },
+      "re": {
+        "title": "Reference electrode",
+        "param": "electrodes.reference",
+        "type": "dataset"
+      },
+      "voltage_limit_one": {
+        "title": "Potential window",
+        "param": "meas.voltage_limit_one",
+        "type": "dataset"
+      },
+      "voltage_limit_two": {
+        "title": "Potential window",
+        "param": "meas.voltage_limit_two",
+        "type": "dataset"
+      },
+      "reference_internal": {
+        "title": "Internal reference compound_inchikey",
+        "param": "meas.reference_internal",
+        "type": "dataset"
+      },
+      "elect_inchikey": {
+        "title": "Electrolyte_inchikey",
+        "param": "sample_preparation.salt",
+        "type": "dataset"
+      },
+      "elect_concentration": {
+        "title": "Electrolyte concentration [M]",
+        "param": "sample_preparation.concentration_salt",
+        "type": "dataset"
+      },
+      "solvent": {
+        "title": "Solvent A_inchikey",
+        "param": "sample_preparation.solvent",
+        "type": "dataset"
+      },
+      "solvent_volume": {
+        "title": "Solvent volume [ml]",
+        "param": "sample_preparation.amount_sol",
+        "type": "dataset"
+      },
+      "solvent_molfile": {
+        "title": "Solvent A_molfile",
+        "param": "n/a",
+        "type": "string"
+      },
+      "scan_direction": {
+        "title": "Scan direction",
+        "param": "n/a",
+        "type": "string"
+      },
+      "reference_internal_compound_molfile": {
+        "title": "Internal reference compound_molfile",
+        "param": "n/a",
+        "type": "string"
+      },
+      "elect_purity": {
+        "title": "Electrolyte purity [%]",
+        "param": "n/a",
+        "type": "string"
+      },
+      "redox": {
+        "title": "Redox-Potential",
+        "param": "n/a",
+        "type": "string"
+      },
+      "elect_molfile": {
+        "title": "Electrolyte_inchikey",
+        "param": "n/a",
+        "type": "string"
+      },
+      "inchikey": {
+        "title": "Analyte_inchikey",
+        "param": "inchikey",
+        "type": "molecule"
+      },
+      "molfile": {
+        "title": "Analyte_molfile",
+        "param": "molfile",
+        "type": "sample"
+      },
+      "details": {
+        "title": "Details",
+        "param": "n/a",
+        "type": "string"
+      },
+      "includes": {
+        "title": "Included",
+        "param": "n/a",
+        "type": "string"
+      },
+      "base_page": {
+        "title": "BasePageName",
+        "param": "n/a",
+        "type": "string"
+      }
+    }
+  }
+}

data/lib/labimotion/libs/export_dataset.rb

@@ -8,47 +8,190 @@ module Labimotion
     DEFAULT_ROW_WIDTH = 100
     DEFAULT_ROW_HEIGHT = 20
 
-    def initialize(**args)
+    def initialize(id)
       @xfile = Axlsx::Package.new
-      @file_extension = 'xlsx'
       @xfile.workbook.styles.fonts.first.name = 'Calibri'
+      @file_extension = 'xlsx'
+
+      @id = id
+      @dataset = Labimotion::Dataset.find_by(element_id: @id, element_type: 'Container')
+      return if @dataset.nil?
+
+      @klass = @dataset.dataset_klass
+      @ols_term_id = @klass.ols_term_id
+      @label = @klass.label
+      @analysis = @dataset&.element&.parent
+      @element = @analysis&.root&.containable if @analysis.present?
+      @element_type = @element.class.name if @element.present?
+    end
+
+    def read
+      @xfile.to_stream.read
     end
 
-    def res_name(id)
-      element_name = Container.find(id)&.root_element&.short_label
-      ols = ols_name(id)
+    def res_name
+      element_name = Container.find(@id)&.root_element&.short_label
+      ols = ols_name
       "#{element_name}_#{ols.gsub(' ', '_')}.xlsx"
     rescue StandardError => e
       Labimotion.log_exception(e)
     end
 
-    def ols_name(id)
-      ds = Labimotion::Dataset.find_by(element_id: id, element_type: 'Container')
-      return nil if ds.nil?
+    def spectra
+      name_mapping = []
+      ## gds = Labimotion::Dataset.find_by(element_id: id, element_type: 'Container')
+      cds = Container.find(@id)
+      cds_csv = cds.attachments.where(aasm_state: 'csv').order(:filename)
+      csv_length = cds_csv.length
+      return if csv_length.zero?
+
+      cds_csv.each_with_index do |att, idx|
+        sheet_name = "Sheet#{idx+1}"
+        sheet = @xfile.workbook.add_worksheet(name: sheet_name)
+        name_mapping.push([sheet_name, att.filename])
+        File.open(att.attachment_url) do |fi|
+          fi.each_line do |line|
+            sheet.add_row(line.split(','))
+          end
+        end
+      end
+      return unless name_mapping.length > 1
+
+      first_sheet = @xfile.workbook.worksheets&.first
+      header_style = first_sheet&.styles.add_style(sz: 12, fg_color: 'FFFFFF', bg_color: '00008B', border: { style: :thick, color: 'FF777777', edges: [:bottom] })
+      first_sheet&.add_row(['Sheet name', 'File name'], style: header_style)
+      name_mapping&.each do |mapping|
+        next if mapping.length < 2
+
+        @xfile.workbook.worksheets&.first&.add_row([mapping[0].to_s, mapping[1].to_s])
+      end
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+    end
+
+    def export
+      return if @dataset.nil? || @analysis.nil? || @element.nil?
+
+      description
+      dataset_info
+      # element_info
+      chemwiki_info
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+    end
+
+    private
+
+    def chemwiki_info
+      config = Labimotion::MapperUtils.load_config(File.read(Constants::Mapper::WIKI_CONFIG))
+      return if config.nil? || config[@ols_term_id].nil?
 
-      name = ds.dataset_klass.label
+      sheet = @xfile.workbook.add_worksheet(name: 'ChemWiki')
+      map_index = config.dig(@ols_term_id, 'index')
+      map_mapper = config.dig(@ols_term_id, 'mapper')
+      map_source = config.dig(@ols_term_id, 'source')
 
-      match = name.match(/\((.*?)\)/)
-      name = match && match.length > 1 ? match[1] : name
+      return if map_index.nil? || map_mapper.nil? || map_source.nil?
 
-      name = '1H NMR' if ds.dataset_klass.ols_term_id == 'CHMO:0000593'
-      name = '13C NMR' if ds.dataset_klass.ols_term_id == 'CHMO:0000595'
+      return unless map_index.is_a?(Array) && map_mapper.is_a?(Hash) && map_source.is_a?(Hash)
+
+      # sheet.column_info.each { |col| col.width = map_width }
+
+      array_header = []
+      array_data = []
+      map_index.each do |key|
+        mapper = map_mapper.dig(key)
+        next if mapper.nil? || mapper['sources'].nil? || !mapper.is_a?(Hash)
+
+        col_header = ''
+        col_value = ''
+        mapper['sources'].each_with_index do |source_key, idx|
+          source = map_source&.dig(source_key)
+          next if source.nil? || source['title'].nil?
+
+          col_header = source['title']
+
+          if col_value.present?
+            col_value += (mapper['separator'] || '') + source_data(source)
+          else
+            col_value = source_data(source)
+          end
+        end
+        array_header.push(col_header || '')
+        array_data.push(col_value || '')
+      end
+      sheet.add_row(array_header)
+      sheet.add_row(array_data)
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+    end
+
+
+    def conv_value(field, properties)
+      return '' if field.nil?
+
+      case field['type']
+      when 'select'
+        Labimotion::Utils.find_options_val(field, properties) || field['value']
+      else
+        field['value']
+      end
+    end
+
+    def source_data(source)
+      param = source['param']
+      return '' if param.nil? || source['type'].nil?
+
+      val = case source['type']
+            when 'string'
+              param
+            when 'sample'
+              @element.send(param) if @element.respond_to?(param)
+            when 'molecule'
+              @element.molecule.send(param) if @element_type == 'Sample' && @element&.molecule&.respond_to?(param)
+            when 'dataset'
+              field = Labimotion::Utils.find_field(@dataset.properties, param)
+              # (field && field['value']) || ''
+              conv_value(field, @dataset.properties)
+            end
+      val || ''
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+    end
+
+    def element_info
+      if @element.class.name == 'Sample'
+        sheet = @xfile.workbook.add_worksheet(name: 'Element')
+        sheet.add_row(['inchikey', @element.molecule_inchikey])
+        sheet.add_row(['molfile', @element.molfile])
+      end
+    rescue StandardError => e
+      Labimotion.log_exception(e)
+    end
+
+    def ols_name
+      #name = @dataset.dataset_klass.label
+
+      match = @label.match(/\((.*?)\)/)
+      name = match && match.length > 1 ? match[1] : @label
+
+      name = '1H NMR' if @ols_term_id == 'CHMO:0000593'
+      name = '13C NMR' if @ols_term_id == 'CHMO:0000595'
       name.slice(0, 26)
     rescue StandardError => e
       Labimotion.log_exception(e)
       'ols_name'
     end
 
-    def description(ds, id)
-      wb = @xfile.workbook
+    def description
       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(['File name', res_name])
       sheet.add_row(['Time', Time.now.strftime("%Y-%m-%d %H:%M:%S %Z")] )
       sheet.add_row(['(This file is automatically generated by the system.)'])
       sheet.add_row([''])
       sheet.add_row([''])
-      sheet.add_row(['Fields description of sheet:' + ds.dataset_klass.label])
+      sheet.add_row(['Fields description of sheet:' + @dataset.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'])
@@ -65,24 +208,18 @@ module Labimotion
       Labimotion.log_exception(e)
     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)
+    def dataset_info
+      name = ols_name
       return if name.nil?
 
       sheet = @xfile.workbook.add_worksheet(name: name)
-      sheet.add_row([ds.dataset_klass.label])
+      sheet.add_row([@dataset.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[Labimotion::Prop::LAYERS] || {}
-      options = ds.properties[Labimotion::Prop::SEL_OPTIONS]
+      layers = @dataset.properties[Labimotion::Prop::LAYERS] || {}
+      options = @dataset.properties[Labimotion::Prop::SEL_OPTIONS]
       layer_keys = layers.keys.sort_by { |key| layers[key]['position'] }
       layer_keys.each do |key|
         layer = layers[key]
@@ -116,8 +253,6 @@ module Labimotion
           end
           sheet.rows.last.cells[2].value = show_value
           sheet.rows.last.cells[8].value = field['system'] || field['device']
-
-
         end
         # sheet.column_widths nil, nil, nil, nil, 0, 0, 0, 0, 0
       end
@@ -136,45 +271,9 @@ module Labimotion
       field['value']
     end
 
-    def spectra(id)
-      name_mapping = []
-      wb = @xfile.workbook
-      gds = Labimotion::Dataset.find_by(element_id: id, element_type: 'Container')
-      cds = Container.find(id)
-      cds_csv = cds.attachments.where(aasm_state: 'csv').order(:filename)
-      csv_length = cds_csv.length
-      return if csv_length.zero?
-      cds_csv.each_with_index do |att, idx|
-        sheet_name = "Sheet#{idx+1}"
-        sheet = @xfile.workbook.add_worksheet(name: sheet_name)
-        name_mapping.push([sheet_name, att.filename])
-        File.open(att.attachment_url) do |fi|
-          fi.each_line do |line|
-            sheet.add_row(line.split(','))
-          end
-        end
-      end
-
-      if name_mapping.length > 1
-        first_sheet = @xfile.workbook.worksheets&.first
-        header_style = first_sheet&.styles.add_style(sz: 12, fg_color: 'FFFFFF', bg_color: '00008B', border: { style: :thick, color: 'FF777777', edges: [:bottom] })
-        first_sheet&.add_row(['Sheet name', 'File name'], style: header_style)
-        name_mapping&.each do |mapping|
-          next if mapping.length < 2
-
-          @xfile.workbook.worksheets&.first&.add_row([mapping[0].to_s, mapping[1].to_s])
-        end
-      end
-
-    end
-
     def header
       ['Layer Label', 'Field Label', 'Value', 'Unit', 'Name', 'Type', 'Source?', 'Source identifier', 'Source data', 'Ontology', 'Ontology Label', 'iri'].freeze
     end
 
-    def read
-      @xfile.to_stream.read
-    end
-
   end
 end

data/lib/labimotion/libs/nmr_mapper.rb

@@ -76,7 +76,7 @@ module Labimotion
 
       def finalize_ds(new_prop)
         Constants::FG_FINALIZE.each do |field_path|
-          field = find_field(new_prop, field_path)
+          field = Labimotion::Utils.find_field(new_prop, field_path)
           next unless field
 
           update_finalized_field(field)
@@ -86,7 +86,7 @@ module Labimotion
 
       def sys_to_ds(new_prop, element, current_user)
         Constants::FG_SYSTEM.each do |field_path|
-          field = find_field(new_prop, field_path)
+          field = Labimotion::Utils.find_field(new_prop, field_path)
           next unless field
 
           update_system_field(field, current_user, element)
@@ -185,16 +185,8 @@ module Labimotion
           Constants::DUP_FIELDS.exclude?(param_key.to_s.downcase)
       end
 
-      def find_field(properties, field_path)
-        layer_name, field_name = field_path.split('.')
-        fields = properties.dig(Labimotion::Prop::LAYERS, layer_name, Labimotion::Prop::FIELDS)
-        return unless fields
-
-        fields.find { |f| f['field'] == field_name }
-      end
-
       def update_param_field(properties, field_path, param_key, metadata)
-        field = find_field(properties, field_path)
+        field = Labimotion::Utils.find_field(properties, field_path)
         return unless field
 
         update_field_value(field, param_key, metadata)

data/lib/labimotion/utils/utils.rb

@@ -80,6 +80,28 @@ module Labimotion
       current_version
     end
 
+    def self.find_field(properties, field_path, separator = '.')
+      return if properties.nil? || field_path.nil?
+
+      layer_name, field_name = field_path.split(separator)
+      fields = properties.dig(Labimotion::Prop::LAYERS, layer_name, Labimotion::Prop::FIELDS)
+      return unless fields
+
+      fields.find { |f| f['field'] == field_name }
+    end
+
+    def self.find_options_val(field, properties)
+      return if field.nil? || properties.nil? || field['option_layers'].nil? || field['value'].nil?
+
+      option_layers = properties.dig(Labimotion::Prop::SEL_OPTIONS, field['option_layers'])
+      options = option_layers && option_layers['options']
+      return if options.nil?
+
+      sel_option = options.find { |o| o['key'] = field['value'] }
+      sel_option && sel_option['label']
+
+    end
+
     def self.pkg(pkg)
       pkg = {} if pkg.nil?
       pkg['eln'] = Chemotion::Application.config.version

data/lib/labimotion/version.rb

@@ -2,5 +2,5 @@
 
 ## Labimotion Version
 module Labimotion
-  VERSION = '2.0.0.rc3'
+  VERSION = '2.0.0.rc4'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labimotion
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc3
+  version: 2.0.0.rc4
 platform: ruby
 authors:
 - Chia-Lin Lin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-02-14 00:00:00.000000000 Z
+date: 2025-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -76,6 +76,7 @@ files:
 - lib/labimotion/helpers/vocabulary_helpers.rb
 - lib/labimotion/libs/attachment_handler.rb
 - lib/labimotion/libs/converter.rb
+- lib/labimotion/libs/data/mapper/Chemwiki.json
 - lib/labimotion/libs/data/mapper/Source.json
 - lib/labimotion/libs/data/vocab/Standard.json
 - lib/labimotion/libs/data/vocab/System.json